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

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

@@ -0,0 +1,101 @@
+module Gecode
+  class Model
+    # Specifies an integer regexp that matches +regexp+ repeated between
+    # +at_least+ and +at_most+ times (inclusive). If +at_most+ is
+    # omitted then no upper bound is placed. If both +at_least+ and
+    # +at_most+ are omitted then no bounds are placed.
+    #
+    # See IntEnum::Extensional::RegexpConstraint for the
+    # allowed syntax of +regexp+.
+    def repeat(regexp, at_least = nil, at_most = nil)
+      unless at_least.nil? or at_least.kind_of? Fixnum
+        raise TypeError, 
+          "Expected the at_least argument to be a Fixnum, got #{at_least.class}"
+      end
+      unless at_most.nil? or at_most.kind_of?(Fixnum)
+        raise TypeError, 
+          "Expected the at_most argument to be a Fixnum, got #{at_most.class}"
+      end
+
+      reg = Util::Extensional.parse_regexp regexp
+      if at_most.nil?
+        if at_least.nil?
+          reg.send '*'
+        else
+          reg.send('()', at_least)
+        end
+      else
+        reg.send('()', at_least, at_most)
+      end
+    end
+
+    # Matches +regexp+ repeated zero or one time (i.e. like '?' in normal 
+    # regexps). Produces the same result as calling 
+    #   
+    #   repeat(regexp, 0, 1)
+    def at_most_once(regexp)
+      repeat(regexp, 0, 1)
+    end
+    
+    # Matches +regexp+ repeated at least one time (i.e. like '+' in normal 
+    # regexps). Produces the same result as calling 
+    #   
+    #   repeat(regexp, 1)
+    def at_least_once(regexp)
+      repeat(regexp, 1)
+    end
+
+    # Matches any of the specified +regexps+.
+    def any(*regexps)
+      regexps.inject(Gecode::Raw::REG.new) do |result, regexp|
+        result | Util::Extensional.parse_regexp(regexp)
+      end
+    end
+  end
+
+  module Util::Extensional
+    module_function
+
+    # Parses a regular expression over the integer domain, returning
+    # an instance of Gecode::REG .
+    #
+    # Pseudo-BNF of the integer regexp representation:
+    # regexp ::= <Fixnum> | <TrueClass> | <FalseClass> | <Gecode::Raw::REG> 
+    #          | [<regexp>, ...]
+    def parse_regexp(regexp)
+      # Check the involved types.
+      unless regexp.kind_of? Enumerable
+        regexp = [regexp]
+      end
+      regexp.to_a.flatten.each do |element|
+        unless element.kind_of?(Fixnum) or element.kind_of?(Gecode::Raw::REG) or
+            element.kind_of?(TrueClass) or element.kind_of?(FalseClass)
+          raise TypeError, 
+            "Can't translate #{element.class} into integer or boolean regexp."
+        end
+      end
+
+      # Convert it into a regexp.
+      internal_parse_regexp(regexp)
+    end
+
+    private
+
+    # Recursively converts arg into an instance of Gecode::REG. It is
+    # assumed that arg is of kind Gecode::Raw::REG, Fixnum, TrueClass,
+    # FalseClass or Enumerable.
+    def self.internal_parse_regexp(arg)
+      case arg 
+        when Gecode::Raw::REG: arg
+        when Fixnum: Gecode::Raw::REG.new(arg)
+        when TrueClass: Gecode::Raw::REG.new(1)
+        when FalseClass: Gecode::Raw::REG.new(0)
+        when Enumerable
+          # Recursively convert the elements of the arg.
+          arg.inject(Gecode::Raw::REG.new) do |regexp, element|
+            regexp += internal_parse_regexp(element)
+          end
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/fixnum_enum/element.rb

@@ -0,0 +1,63 @@
+module Gecode::FixnumEnum
+  module FixnumEnumOperand
+    # This adds the adder for the methods in the modules including it. The 
+    # reason for doing it so indirect is that the first #[] won't be defined 
+    # before the module that this is mixed into is mixed into an enum.
+    def self.included(enum_mod) #:nodoc:
+      enum_mod.module_eval do
+        # Now we enter the module FixnumEnumOperands is mixed into.
+        class << self
+          alias_method :pre_element_included, :included
+          def included(mod) #:nodoc:
+            mod.module_eval do
+              if instance_methods.include? '[]'
+                alias_method :pre_element_access, :[]
+              end
+          
+              # Produces an IntOperand representing the
+              # i:th constant integer in the enumeration, where i is the
+              # value of the integer operand used as index. Think of it
+              # as array access in the world of constraint programming.
+              # 
+              # ==== Examples 
+              # 
+              #   # The price of +selected_item+ as described by +prices+ .
+              #   prices = wrap_enum([500, 24, 4711, 412, 24])
+              #   prices[selected_item]
+              # 
+              def [](*vars)
+                if vars.first.respond_to? :to_int_var
+                  return Element::ElementIntOperand.new(
+                    self, vars.first, model)
+                else
+                  pre_element_access(*vars) if respond_to? :pre_element_access
+                end
+              end
+            end
+            pre_element_included(mod)
+          end
+        end
+      end
+    end
+  end
+
+  module Element #:nodoc:
+    class ElementIntOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(enum_op, position_int_var_op, model)
+        super model
+        @enum = enum_op
+        @position = position_int_var_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        if constrain
+          int_operand.must_be.in @enum
+        end
+
+        Gecode::Raw::element(@model.active_space, @enum, 
+          @position.to_int_var.bind, int_operand.to_int_var.bind, 
+          *propagation_options)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/fixnum_enum/operation.rb

@@ -0,0 +1,65 @@
+module Gecode::FixnumEnum
+  module FixnumEnumOperand
+    # Produces a new SetOperand representing the union between this operand, 
+    # interpreted as a constant set, and +set_operand+.
+    #
+    # ==== Examples 
+    #
+    #   # The union between +fixnum_enum+ and +set+.
+    #   fixnum_enum.union set
+    def union(set_operand)
+      set_operation(:union, set_operand)
+    end
+
+    # Produces a new SetOperand representing the disjoint union between
+    # this operand, interpreted as a constant set, and
+    # +set_operand+. The disjoint union is the union of
+    # the disjoint parts of the sets.
+    #
+    # ==== Examples 
+    #
+    #   # The disjoint union between +fixnum_enum+ and +set+.
+    #   fixnum_enum.disjoint_union set
+    def disjoint_union(set_operand)
+      set_operation(:disjoint_union, set_operand)
+    end
+
+    # Produces a new SetOperand representing the intersection between
+    # this operand, interpreted as a constant set, and
+    # +set_operand+. 
+    #
+    # ==== Examples 
+    #
+    #   # The intersection between +fixnum_enum+ and +set+.
+    #   fixnum_enum.intersection set
+    def intersection(set_operand)
+      set_operation(:intersection, set_operand)
+    end
+
+    # Produces a new SetOperand representing this operand, interpreted
+    # as a constant set, minus +set_operand+. 
+    #
+    # ==== Examples 
+    #
+    #   # +fixnum_enum+ minus +set+.
+    #   fixnum_enum.minus set
+    def minus(set_operand)
+      set_operation(:minus, set_operand)
+    end
+
+    private 
+
+    # Starts a constraint on this set #{name} the specified set.
+    def set_operation(operator, operand2)
+      unless operand2.respond_to? :to_set_var
+        raise TypeError, 'Expected set operand as ' + 
+          "operand, got \#{operand2.class}."
+      end
+
+      return Operation::OperationSetOperand.new(model, self, 
+        operator, operand2)
+    end
+  end
+
+  Operation = Gecode::Set::Operation
+end

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

@@ -0,0 +1,42 @@
+# A module containing constraints that have enumerations of instances of
+# Fixnum as left hand side.
+module Gecode::FixnumEnum #:nodoc:
+  # A FixnumEnumOperand is a enumeration of Fixnum on which the
+  # constraints defined in FixnumEnumConstraintReceiver can be placed.
+  # They typically service as constant arrays or constant sets.
+  #
+  # The fixnum enumeration operands are created by wrapping an enumeration 
+  # of fixnum Gecode::Model#wrap_enum. The enumerations created that way
+  # all respond to the properties defined by FixnumEnumOperand.
+  #
+  # ==== Examples 
+  #
+  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # a FixnumEnumOperand from an existing enumeration of Fixnum:
+  #
+  #   fixnum_enum = wrap_enum([3, 5, 7])
+  #   
+  #--
+  # Classes that mix in FixnumEnumOperand must define #model.
+  module FixnumEnumOperand
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::FixnumEnum::Dummy.instance_methods.include? method.to_s
+        # Delegate to the fixnum enum.
+        to_fixnum_enum.method(method).call(*args)
+      else
+        super
+      end
+    end
+
+    private
+  
+    def construct_receiver(params)
+      raise NotImplementedError, 'Fixnum enums do not have constraints.'
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/fixnum_enum/element'
+require 'gecoder/interface/constraints/fixnum_enum/operation'

data/lib/gecoder/interface/constraints/int/arithmetic.rb

@@ -0,0 +1,150 @@
+module Gecode::Int
+  module IntOperand
+    # Produces an IntOperand representing the absolute value of this 
+    # operand.
+    #
+    # ==== Examples 
+    #   
+    #   # The absolute value of +int_op+.
+    #   int_op.abs
+    def abs
+      Arithmetic::IntAbsOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing this operand squared.
+    #
+    # ==== Examples 
+    #   
+    #   # The value of +int_op*int_op+.
+    #   int_op.squared
+    def squared
+      Arithmetic::IntSquaredOperand.new(@model, self)
+    end
+
+    # Produces an IntOperand representing the square root of this 
+    # operand rounded down.
+    #
+    # ==== Examples 
+    #   
+    #   # The square root of +int_op+, rounded down.
+    #   int_op.square_root
+    def square_root
+      Arithmetic::IntSquareRootOperand.new(@model, self)
+    end
+    alias_method :sqrt, :square_root
+
+
+    alias_method :pre_arith_mult, :* 
+    
+    # Produces a new IntOperand representing this operand times
+    # +int_operand+.
+    #
+    # ==== Examples 
+    #   
+    #   # The value of +int_op1+ times +int_op2+.
+    #   int_op1 * int_op2
+    def *(int_operand)
+      if int_operand.respond_to? :to_int_var
+        Arithmetic::IntMultOperand.new(@model, self, int_operand)
+      else
+        pre_arith_mult(int_operand) 
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used by arithmetic 
+  # constraints.
+  module Arithmetic #:nodoc:
+    class IntAbsOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          bounds = [int_op.min.abs, int_op.max.abs]
+          bounds << 0 if int_op.min < 0
+          int_operand.must_be.in bounds.min..bounds.max
+        end
+        
+        Gecode::Raw::abs(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+    
+    class IntMultOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, op1, op2)
+        super model
+        @op1 = op1
+        @op2 = op2
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op1, int_op2 = @op1.to_int_var, @op2.to_int_var
+        if constrain
+          a_min = int_op1.min; a_max = int_op1.max
+          b_min = int_op2.min; b_max = int_op2.max
+          products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
+          int_operand.must_be.in products.min..products.max
+        end
+
+        Gecode::Raw::mult(@model.active_space, int_op1.to_int_var.bind, 
+          int_op2.to_int_var.bind, int_operand.to_int_var.bind, 
+          *propagation_options)
+      end
+    end
+    
+    class IntSquaredOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          min = int_op.min; max = int_op.max
+          products = [min*max, min*min, max*max]
+          int_operand.must_be.in products.min..products.max
+        end
+
+        Gecode::Raw::sqr(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+    
+    class IntSquareRootOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          max = int_op.max
+          if max < 0
+            # The left hand side does not have a real valued square root.
+            upper_bound = 0
+          else
+            upper_bound = Math.sqrt(max).floor;
+          end
+          
+          min = int_op.min
+          if min < 0
+            lower_bound = 0
+          else
+            lower_bound = Math.sqrt(min).floor;
+          end
+          
+          int_operand.must_be.in lower_bound..upper_bound
+        end
+
+        Gecode::Raw::sqrt(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Gecode::Int
+  class IntConstraintReceiver
+    alias_method :pre_channel_equals, :==
+    
+    # Constrains the integer operand to be equal to the specified boolean 
+    # operand. I.e. constrains the integer operand to be 1 when the boolean
+    # operand is true and 0 if the boolean operand is false.
+    #
+    # ==== Examples 
+    #
+    #   # The integer operand +int+ must be one exactly when the boolean 
+    #   # operand +bool+ is true.
+    #   int.must == bool
+    def ==(bool, options = {})
+      unless @params[:lhs].respond_to? :to_int_var and 
+          bool.respond_to? :to_bool_var
+        return pre_channel_equals(bool, options)
+      end
+      
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' +
+          'is not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the channel ' + 
+          'constraint.'
+      end
+      
+      @params.update(Gecode::Util.decode_options(options))
+      @params[:rhs] = bool
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+    
+    alias_comparison_methods
+    
+    # Provides commutativity with BoolEnumConstraintReceiver#channel .
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_bool_enum }
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints
+  # involving a single integer operand.
+  module Channel #:nodoc:
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, lhs.to_int_var.bind, 
+          rhs.to_bool_var.bind, *propagation_options)
+      end
+    end
+  end
+end