gecoder 0.8.3 → 0.9.0

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

@@ -1,149 +1,150 @@
-class Gecode::FreeIntVar
-  # Initiates an arithmetic absolute value constraint.
-  def abs
-    Gecode::Constraints::Int::Arithmetic::AbsExpressionStub.new(@model, 
-      :lhs => self)
-  end
-  
-  # Initiates an arithmetic squared value constraint.
-  def squared
-    Gecode::Constraints::Int::Arithmetic::SquaredExpressionStub.new(@model, 
-      :lhs => self)
-  end
-
-  # Initiates an arithmetic squared root constraint.
-  def sqrt
-    Gecode::Constraints::Int::Arithmetic::SquareRootExpressionStub.new(@model, 
-      :lhs => self)
-  end
-  alias_method :square_root, :sqrt
-
+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
 
-  alias_method :pre_arith_mult, :* if instance_methods.include? '*'
-  
-  # Begins a multiplication constraint involving the two int variable.
-  def *(var)
-    if var.kind_of? Gecode::FreeIntVar
-      Gecode::Constraints::Int::Arithmetic::MultExpressionStub.new(
-        @model, :lhs => self, :var => var)
-    else
-      pre_arith_mult(var) if respond_to? :pre_arith_mult
+    # 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
-  end
-end
+    alias_method :sqrt, :square_root
 
-# A module that gathers the classes and modules used by arithmetic constraints.
-module Gecode::Constraints::Int::Arithmetic #:nodoc:
-  # Describes a CompositeStub for absolute value constraints, which constrain
-  # the absolute value of an integer variable.
-  # 
-  # == Examples
-  #   
-  #   # The absolute value of +x+ must be less than 2.
-  #   x.abs.must < 2
-  #   
-  #   # The absolute value of +x+ must be in the range 5..7, with +bool+ as 
-  #   # reification variable and +value+ as strength.
-  #   x.abs.must_be.in(5..7, :reify => bool, :strength => :value)
-  class AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        bounds = [lhs.min.abs, lhs.max.abs]
-        variable.must_be.in bounds.min..bounds.max
+
+    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
-      
-      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
     end
   end
   
-  # Describes a CompositeStub for multiplication constraint, which constrain
-  # the value of the multiplication of two variables.
-  # 
-  # == Examples
-  #   
-  #   # The value of +x*y+ must be equal to their sum.
-  #   (x*y).must == x + y
-  #   
-  #   # The value of +x*y+ must be less than 17, with +bool+ as reification 
-  #   # variable and +domain+ as strength.
-  #   (x*y).must_be.less_than(17, :reify => bool, :strength => :domain)
-  class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs, lhs2 = @params.values_at(:lhs, :var)
-      if constrain
-        a_min = lhs.min; a_max = lhs.max
-        b_min = lhs2.min; b_max = lhs2.max
-        products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
-        variable.must_be.in products.min..products.max
+  # 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
 
-      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
-        variable.bind, *propagation_options)
+      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
-  end
-  
-  # Describes a CompositeStub for the squared constraint, which constrain
-  # the squared value of the variable.
-  # 
-  # == Examples
-  #   
-  #   # The value of +x*x+ must be equal to y.
-  #   x.squared.must == y
-  #   
-  #   # The value of +x*x+ must be less than or equal to 16, with +bool+ as 
-  #   # reification variable and +domain+ as strength.
-  #   x.squared.must_be.less_or_equal(16, :reify => bool, :strength => :domain)
-  class SquaredExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        min = lhs.min; max = lhs.max
-        products = [min*max, min*min, max*max]
-        variable.must_be.in products.min..products.max
+    
+    class IntMultOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, op1, op2)
+        super model
+        @op1 = op1
+        @op2 = op2
       end
 
-      Gecode::Raw::sqr(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
-    end
-  end
-  
-  # Describes a CompositeStub for the square root constraint, which constrain
-  # the rounded down square root of the variable.
-  # 
-  # == Examples
-  #   
-  #   # The square root of +x+, rounded down, must equal y.
-  #   x.square_root.must == y   
-  #
-  #   # The square root of +x+, rounded down, must be larger than 17, with 
-  #   # +bool+ as reification variable and +domain+ as strength.
-  #   x.square_root.must_be.larger_than(17, :reify => bool, :strength => :domain)
-  class SquareRootExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        max = lhs.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;
+      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
-        
-        min = lhs.min
-        if min < 0
-          lower_bound = 0
-        else
-          lower_bound = Math.sqrt(min).floor;
+
+        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
-        
-        variable.must_be.in lower_bound..upper_bound
+
+        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
 
-      Gecode::Raw::sqrt(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
+      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