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

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

@@ -0,0 +1,68 @@
+module Gecode::BoolEnum
+  class BoolEnumConstraintReceiver
+    # Constrains this enumeration to "channel" +integer_operand+. This 
+    # constrains the integer operand to take value i exactly when the 
+    # operand at index i in the boolean enumeration is true and the others 
+    # are false.
+    # 
+    # Beyond the common options the channel constraint can
+    # also take the following option:
+    #
+    # [:offset]  Specifies an offset for the integer operand. If the offset is
+    #            set to k then the integer operand takes value i+k exactly 
+    #            when the operand at index i in the boolean enumeration is 
+    #            true and the rest are false.
+    # 
+    # Neither reification nor negation is supported. The int operand
+    # and the enumeration can be interchanged.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the enumeration called +option_is_selected+ to be false 
+    #   # in the first four positions and have exactly one true operand in 
+    #   # the other. 
+    #   option_is_selected.must.channel selected_option_index 
+    #   selected_option_index.must_be > 3
+    #
+    #   # Constrains the enumeration called +option_is_selected+ to be false 
+    #   # in the first five positions and have exactly one true operand in 
+    #   # the other. 
+    #   selected_option_index.must.channel(option_is_selected, :offset => 1) 
+    #   selected_option_index.must_be > 3
+    def channel(integer_operand, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraint does not support the ' + 
+          'reification option.'
+      end
+      unless integer_operand.respond_to? :to_int_var
+        raise TypeError, 'Expected an integer operand, got ' + 
+          "#{integer_operand.class}."
+      end
+      
+      @params.update(:rhs => integer_operand, 
+        :offset => options.delete(:offset) || 0)
+      @params.update(Gecode::Util.decode_options(options))
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+
+    # Provides commutativity with SetConstraintReceiver#channel
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_set_var }
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints
+  # involving one boolean enum and one integer operand.
+  module Channel #:nodoc:
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
+      def post
+        lhs, rhs, offset = @params.values_at(:lhs, :rhs, :offset)
+        Gecode::Raw::channel(@model.active_space, 
+          lhs.to_bool_enum.bind_array, rhs.to_int_var.bind, 
+          offset, *propagation_options)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/bool_enum/extensional.rb

@@ -0,0 +1,106 @@
+module Gecode::BoolEnum
+  class BoolEnumConstraintReceiver
+    # Constrains all the operands in this enumeration to be equal to
+    # one of the specified tuples. Neither negation nor reification is
+    # supported.
+    #
+    # ==== Examples 
+    # 
+    #   # Constrains the three boolean operands in +bools+ to either
+    #   # be true, false, true, or false, false, true.
+    #   bools.must_be.in [[true, false, true], [false, false, true]]
+    #
+    #   # The same as above, but preferring speed over low memory usage.
+    #   bools.must_be.in([[true, false, true], [false, false, true]], 
+    #     :kind => :speed)
+    def in(tuples, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated tuple constraint is ' +
+          'not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the tuple ' + 
+          'constraint.'
+      end
+      
+      util = Gecode::Util
+      
+      # Check that the tuples are correct.
+      expected_size = @params[:lhs].size
+      util::Extensional.perform_tuple_checks(tuples, expected_size) do |tuple|
+        unless tuple.all?{ |x| x.kind_of?(TrueClass) or x.kind_of?(FalseClass) }
+          raise TypeError, 'All tuples must contain booleans.'
+        end
+      end
+      
+      @params[:tuples] = tuples
+      @model.add_constraint Extensional::TupleConstraint.new(@model, 
+        @params.update(Gecode::Util.decode_options(options)))
+    end
+
+    # Constrains the sequence of operands in this enumeration to match
+    # a specified regexp in the boolean domain. Neither negation nor
+    # reification is supported.
+    #
+    # The regular expressions are specified as described in 
+    # IntEnumConstraintReceiver#match but true and false can be
+    # used instead of integers.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the two boolean operands in +bools+ to be false
+    #   # and true respectively.
+    #   bools.must.match [false, true]
+    #
+    #   # Constrains the boolean operands in +bools+ to be false,
+    #   # except for three consecutive operands which should be true
+    #   # followed by false followed by true.
+    #   bools.must.match [repeat(false), true, false, true, repeat(false)]]
+    #
+    def match(regexp, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
+          'is not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the regexp ' + 
+          'constraint.'
+      end
+
+      @params[:regexp] = 
+        Gecode::Util::Extensional.parse_regexp regexp
+      @params.update Gecode::Util.decode_options(options)
+      @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in extensional 
+  # constraints.
+  module Extensional #:nodoc:
+    class TupleConstraint < Gecode::Constraint #:nodoc:
+      def post
+        # Bind lhs.
+        lhs = @params[:lhs].to_bool_enum.bind_array
+
+        # Create the tuple set.
+        tuple_set = Gecode::Raw::TupleSet.new
+        @params[:tuples].each do |tuple|
+          tuple_set.add tuple.map{ |b| b ? 1 : 0 }
+        end
+        tuple_set.finalize
+
+        # Post the constraint.
+        Gecode::Raw::extensional(@model.active_space, lhs, tuple_set, 
+          *propagation_options)
+      end
+    end
+
+    class RegexpConstraint < Gecode::Constraint #:nodoc:
+      def post
+        lhs, regexp = @params.values_at(:lhs, :regexp)
+        Gecode::Raw::extensional(@model.active_space, 
+          lhs.to_bool_enum.bind_array, regexp, *propagation_options)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/bool_enum/relation.rb

@@ -0,0 +1,55 @@
+module Gecode::BoolEnum
+  module BoolEnumOperand
+    # Produces a BoolOperand that represents the conjunction (AND) of all
+    # boolean operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # Conjunction of all elements in +bool_enum+.
+    #   bool_enum.conjunction
+    def conjunction
+      Relation::BoolEnumConjunctionOperand.new(@model, self)
+    end
+    
+    # Produces a BoolOperand that represents the disjunction (OR) of all
+    # boolean operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # Disjunction of all elements in +bool_enum+.
+    #   bool_enum.disjunction
+    def disjunction
+      Relation::BoolEnumDisjunctionOperand.new(@model, self)
+    end
+  end
+
+  # A module that gathers the classes and modules used by boolean enumeration 
+  # relation constraints.
+  module Relation #:nodoc:
+    class BoolEnumConjunctionOperand < Gecode::Bool::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, bool_enum)
+        super model
+        @enum = bool_enum
+      end
+
+      def constrain_equal(bool_operand, constrain_domain, propagation_options)
+        Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_AND,
+          @enum.to_bool_enum.bind_array, bool_operand.to_bool_var.bind, 
+          *propagation_options)
+      end
+    end
+    
+    class BoolEnumDisjunctionOperand < Gecode::Bool::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, bool_enum)
+        super model
+        @enum = bool_enum
+      end
+
+      def constrain_equal(bool_operand, constrain_domain, propagation_options)
+        Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_OR,
+          @enum.to_bool_enum.bind_array, bool_operand.to_bool_var.bind, 
+          *propagation_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# A module containing constraints that have enumerations of boolean 
+# operands as left hand side.
+module Gecode::BoolEnum #:nodoc:
+  # A BoolEnumOperand is a enumeration of BoolOperand on which the
+  # constraints defined in BoolEnumConstraintReceiver can be placed.
+  #
+  # Enumerations of boolean operands can be created either by using
+  # Gecode::Model#bool_var_array and Gecode::Model#bool_var_matrix, or
+  # by wrapping an existing enumeration containing BoolOperand using
+  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # created, all respond to the properties defined by BoolEnumOperand.
+  #
+  # ==== Examples 
+  #
+  # Produces an array of five boolean operands inside a problem formulation
+  # using Gecode::Model#bool_var_array:
+  #
+  #   bool_enum = bool_var_array(5)
+  #
+  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # a BoolEnumOperand from an existing enumeration containing the
+  # boolean operands +bool_operand1+ and +bool_operand2+:
+  #
+  #   bool_enum = wrap_enum([bool_operand1, bool_operand2])
+  #   
+  #--
+  # Classes that mix in BoolEnumOperand must define #model and
+  # #to_bool_enum .
+  module BoolEnumOperand
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::BoolEnum::Dummy.instance_methods.include? method.to_s
+        # Delegate to the bool enum.
+        to_bool_enum.method(method).call(*args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def construct_receiver(params)
+      BoolEnumConstraintReceiver.new(@model, params)
+    end
+  end
+
+  # BoolEnumConstraintReceiver contains all constraints that can be
+  # placed on a BoolEnumOperand.
+  #
+  # Constraints are placed by calling BoolEnumOperand#must (or any other
+  # of the variations defined in Operand), which produces a
+  # BoolEnumConstraintReceiver from which the desired constraint can be
+  # used.
+  #
+  # ==== Examples 
+  #
+  # Constrains +bool_enum+, with three boolean operands, to take the 
+  # value of the tuples [false, true, false] or [true, false, true] 
+  # using BoolEnumConstraintReceiver#in:
+  #
+  #   bool_enum.must_be.in [[false, true, false], [true, false, true]]
+  #
+  # Constrains +bool_enum+ to channel +int_operand+ using 
+  # BoolEnumConstraintReceiver#channel:
+  #
+  #   bool_enum.must.channel int_operand
+  #
+  class BoolEnumConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is an bool enum
+    # operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_bool_enum
+        raise TypeError, 'Must have bool enum operand as left hand side.'
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/bool_enum/relation'
+require 'gecoder/interface/constraints/bool_enum/extensional'
+require 'gecoder/interface/constraints/bool_enum/channel'

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

@@ -0,0 +1,155 @@
+# A module that deals with the operands, properties and constraints of
+# boolean operands.
+module Gecode::Bool #:nodoc:
+  # A BoolOperand is a combination of variables on which the
+  # constraints defined in BoolConstraintReceiver can be placed.
+  #
+  # Boolean operands can be created either by using
+  # Gecode::Model#bool_var et al, or by using properties that produce
+  # boolean operands. The operands, no matter how they were created, 
+  # all respond to the properties defined by BoolOperand.
+  #
+  # ==== Examples 
+  #
+  # Produces a single boolean operand (more specifically a BoolVar)
+  # inside a problem formulation, using Gecode::Model#bool_var:
+  #
+  #   bool_operand = bool_var
+  #
+  # Uses the BoolOperand#& property to produce a new boolean
+  # operand representing +bool_operand1+ AND +bool_operand2+:
+  #
+  #   new_bool_operand = bool_operand1 & bool_operand2
+  #
+  # Uses the BoolEnumOperand#conjunction property to produce a new
+  # boolean operand representing the conjunction of all boolean operands
+  # in the enumeration +bool_enum+:
+  #
+  #   new_bool_operand = bool_enum.conjunction
+  #
+  #--
+  # Classes that mix in BoolOperand must define #model and #to_bool_var .
+  module BoolOperand  
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::BoolVar.instance_methods.include? method.to_s
+        # Delegate to the bool var.
+        to_bool_var.method(method).call(*args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def construct_receiver(params)
+      BoolConstraintReceiver.new(@model, params)
+    end
+  end
+
+  # BoolConstraintReceiver contains all constraints that can be
+  # placed on a BoolOperand.
+  #
+  # Constraints are placed by calling BoolOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # BoolConstraintReceiver from which the desired constraint can be used.
+  #
+  # Each constraint accepts a number of options. See ConstraintReceiver
+  # for more information.
+  #
+  # ==== Examples 
+  #
+  # Constrains +bool_operand+ to be true using
+  # BoolConstraintReceiver#true:
+  #
+  #   bool_operand.must_be.true
+  #
+  # Constrains +bool_operand1+ AND +bool_operand2+ to be true using 
+  # the BoolOperand#& property and BoolConstraintReceiver#true:
+  #
+  #   (bool_operand1 & bool_operand2).must_be.true
+  #
+  # Constrains the conjunction of all boolean operands in +bool_enum+ to
+  # _not_ imply +bool_operand+ using the 
+  # BoolEnumOperand#conjunction property and BoolConstraintReceiver#imply:
+  #
+  #   bool_enum.conjunction.must_not.imply bool_operand
+  #
+  # The same as above, but specifying that strength :domain should be 
+  # used and that the constraint should be reified with +bool_operand2+:
+  #
+  #   bool_enum.conjunction.must_not.imply(bool_operand, :strength => :domain, :reify => bool_operand2)
+  #
+  class BoolConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is an bool operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_bool_var
+        raise TypeError, 'Must have bool operand as left hand side.'
+      end
+    end
+  end
+
+  # An operand that short circuits boolean equality.
+  class ShortCircuitEqualityOperand #:nodoc:
+    include Gecode::Bool::BoolOperand
+    attr :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def construct_receiver(params)
+      params.update(:lhs => self)
+      receiver = BoolConstraintReceiver.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_bool_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_bool_var
+      variable = model.bool_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 +bool_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 +bool_operand+.
+    def constrain_equal(bool_operand, constrain_domain, propagation_options)
+      raise NotImplementedError, 'Abstract method has not been implemented.'
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/bool/boolean'
+require 'gecoder/interface/constraints/bool/linear'
+require 'gecoder/interface/constraints/bool/channel'