Gecoder C0 Coverage Information - RCov

   # An error signaling that the constraint specified is missing (e.g. one tried

   # to negate a constraint, but no negated form is implemented).

   end

   # Describes an operand, something that a constraint can be placed

   # on. Constraints are placed by calling #must or #must_not (the

   # latter negates the constraint). This produces a

   # ConstraintReceiver, which defines methods that places constraints

   # on the operand.

   #

   # In general this produces something like the following.

   # 

   #   operand.must.constraint_method(params)

   #

   # See e.g. Gecode::Int::IntOperand for concrete examples.

   # 

   # Classes that mix in Operand must define the methods #model

   # and #construct_receiver. They should also define a method that converts

   # the operand into a variable of the operand's type (e.g. int var

   # operands should define a method #to_int_var that returns an

   # instance of Gecode::IntVar that represents the operand). The

   # latter method should be used by constraints to fetch variables

   # needed when posting constraints. The presence of the method should

   # also be used for type checking (rather than e.g. checking whether

   # a parameter is of type IntOperand). 

     # Specifies that a constraint must hold for the left hand side.

     end

     # Specifies that the negation of a constraint must hold for the left hand 

     # side.

     end

     # Fetches the model that the operand belongs to.

     end

     # Constructs the appropriate constraint receiver given the

     # specified parameters.

     end

   end

   # Describes a constraint receiver, something that receives and 

   # places constraints on various Operand. Constraint receivers 

   # are created by calling #must or #must_not (the latter negates 

   # the constraint) on something that mixes in Operand.

   #

   # A constraint is placed on an Operand +operand+ as follows:

   #

   #   operand.must.constraint_method(params)

   #

   # The constraint receiver is created by the call to #must and the

   # constraint is then placed by the call to #constraint_method. 

   # See e.g. Gecode::Int::IntConstraintReceiver for 

   # concrete examples.

   #

   # The following options can be specified in a hash with symbols as

   # keys when placing a constraint:

   #

   # [:strength] The propagation strength suggests how much effort the 

   #             solver should put into trying to prune the domains of 

   #             variables using the constraint. 

   #

   #             The allowed values are:

   #             [:value] Value consistency (naive).

   #             [:bounds] Bounds consistency. The bounds of the operand 

   #                       will always be constrained as much as possible 

   #                       (but pruning may not be done inside the

   #                       bounds, even though it may be possible).

   #             [:domain] Domain consistency. All values that can be pruned 

   #                       away, given the current amount of information,

   #                       are pruned away.

   #             [:default] Uses the default consistency of the constraint.

   #             

   #             The strength generally progresses as 

   #             :value < :bounds < :domain (:value being the weakest, 

   #             :domain being the strongest). A higher strength can 

   #             reduce the search space quicker, but at the cost of 

   #             making each propagation more costly.

   #

   # [:kind]     The propagation kind option suggests the implementation

   #             that should be preferred if there are multiple 

   #             implementations of a constraint. 

   #

   #             The different kinds are:

   #             [:speed] Prefer speed over memory consumption.

   #             [:memory] Prefer low memory consumption over speed.

   #             [:default] Uses the constraint's default propagation kind.

   #

   # [:reify]    Reification is used to link a constraint to a boolean 

   #             operand in such a way that the variable is true if and

   #             only if the constraint is satisfied. The propagation

   #             goes both ways, so if the variable is constrained to be

   #             false then the constraint is not allowed to be

   #             satisfied.

   #

   #             Reification can be thought of as a last resort glue which 

   #             can be used to combine constraints so that e.g. exactly

   #             3 out of 17 constraints must be satisfied.

   #

   # Not all constraints accept all options. Constraints that have sets

   # as operands (e.g. SetConstraintReceiver and

   # SetEnumConstraintReceiver) do not accept the :strength and :kind

   # options, all other do. Some constraints do not accept the :reify

   # option.

   #

   # See e.g. Gecode::Int::IntConstraintReceiver for 

   # concrete examples of options being specified.

     # A list that keeps track of all constraint methods used in the

     # program, essentially providing unique ids for each.

     # Constructs a new expression with the specified parameters. The 

     # parameters should at least contain the keys :lhs, and :negate.

     #

     # Raises ArgumentError if any of those keys are missing or if :lhs

     # is not an operand.

           "and :negate as parameter keys, got #{params.keys.join(', ')}."

       end

         raise ArgumentError, 'Expected :lhs to be an operand, received ' + 

           "#{params[:lhs].class}."

       end

     end

     # Provides commutativity for the constraint with the specified

     # method name. If the method with the specified method name is

     # called with something that, when given to the block, evaluates

     # to true, then the constraint will be called on the right hand

     # side with the left hand side as argument.

     #

     # The original constraint method is assumed to take two arguments:

     # a right hand side and a hash of options.

       end

       end

         @@commutivity_check_#{unique_id} = block

         def #{constraint_name}(rhs, options = {})

           if @@commutivity_check_#{unique_id}.call(rhs, options)

             if @params[:negate]

               rhs.must_not.method(:#{constraint_name}).call(

                 @params[:lhs], options)

             else

               rhs.must.method(:#{constraint_name}).call(

                 @params[:lhs], options)

             end

           else

             if self.class.method_defined? :#{pre_alias_method_name}

               #{pre_alias_method_name}(rhs, options)

             else

               raise TypeError, \"Unexpected argument type \#{rhs.class}.\" 

             end

           end

         end

       end_code

     end

     # Creates aliases for any defined comparison methods.

           end

         end

       end

     end

     # Creates aliases for any defined set methods.

           end

         end

       end

     end

   end

   # Base class for all constraints.

     # Creates a constraint with the specified parameters, bound to the 

     # specified model. 

     end

     # Posts the constraint, adding it to the model. This is an abstract 

     # method and should be overridden by all sub-classes.

     end

     # Gives an array of the values selected for the standard propagation 

     # options (propagation strength and propagation kind) in the order that

     # they are given when posting constraints to Gecode.

     end

   end

   # A constraint that can be specified by providing a block containing the

   # post method.

     end

     end

   end

   # A module that provides some utility-methods for constraints.

     # Maps the name used in options to the value used in Gecode for 

     # propagation strengths.

       :default  => Gecode::Raw::ICL_DEF,

       :value    => Gecode::Raw::ICL_VAL,

       :bounds   => Gecode::Raw::ICL_BND,

       :domain   => Gecode::Raw::ICL_DOM

     }

     # Maps the name used in options to the value used in Gecode for 

     # propagation kinds.

       :default  => Gecode::Raw::PK_DEF,

       :speed    => Gecode::Raw::PK_SPEED,

       :memory   => Gecode::Raw::PK_MEMORY,

     } 

     # Maps the names of the methods to the corresponding integer relation 

     # type in Gecode.

       :== => Gecode::Raw::IRT_EQ,

       :<= => Gecode::Raw::IRT_LQ,

       :<  => Gecode::Raw::IRT_LE,

       :>= => Gecode::Raw::IRT_GQ,

       :>  => Gecode::Raw::IRT_GR

     }

     # The same as above, but negated.

       :== => Gecode::Raw::IRT_NQ,

       :<= => Gecode::Raw::IRT_GR,

       :<  => Gecode::Raw::IRT_GQ,

       :>= => Gecode::Raw::IRT_LE,

       :>  => Gecode::Raw::IRT_LQ

     }

     # Maps the names of the methods to the corresponding set relation type in 

     # Gecode.

       :==         => Gecode::Raw::SRT_EQ,

       :superset   => Gecode::Raw::SRT_SUP,

       :subset     => Gecode::Raw::SRT_SUB,

       :disjoint   => Gecode::Raw::SRT_DISJ,

       :complement => Gecode::Raw::SRT_CMPL

     }

     # The same as above, but negated.

       :== => Gecode::Raw::SRT_NQ

     }

     # Maps the names of the methods to the corresponding set operation type in 

     # Gecode.

       :union          => Gecode::Raw::SOT_UNION,

       :disjoint_union => Gecode::Raw::SOT_DUNION,

       :intersection   => Gecode::Raw::SOT_INTER,

       :minus          => Gecode::Raw::SOT_MINUS

     }

     # Various method aliases for comparison methods. Maps the original 

     # (symbol) name to an array of aliases.

       :== => [:equal, :equal_to],

       :>  => [:greater, :greater_than],

       :>= => [:greater_or_equal, :greater_than_or_equal_to],

       :<  => [:less, :less_than],

       :<= => [:less_or_equal, :less_than_or_equal_to]

     }

       :==         => [:equal, :equal_to],

       :superset   => [:superset_of],

       :subset     => [:subset_of],

       :disjoint   => [:disjoint_with],

       :complement => [:complement_of]

     }

     # Decodes the common options to constraints: strength, kind and 

     # reification. Returns a hash with up to three values. :strength is the 

     # strength that should be used for the constraint, :kind is the 

     # propagation kind that should be used, and :reif is the (bound) boolean 

     # operand that should be used for reification. The decoded options are 

     # removed from the hash (so in general the hash will be consumed in the 

     # process).

     # 

     # Raises ArgumentError if an unrecognized option is found in the specified

     # hash. Or if an unrecognized strength is given. Raises TypeError if the

     # reification operand is not a boolean operand.

       # Propagation strength.

       end

       # Propagation kind.

       end  

       # Reification.

       end

       # Check for unrecognized options.

           options.keys.first.to_s

       end

       return {

         :strength => PROPAGATION_STRENGTHS[strength], 

         :kind => PROPAGATION_KINDS[kind],

     end

     # Converts the different ways to specify constant sets in the interface

     # to the form that the set should be represented in Gecode (possibly 

     # multiple paramters. The different forms accepted are:

     # * Single instance of Fixnum (singleton set).

     # * Range (set containing all numbers in range), treated differently from

     #   other enumerations.

     # * Enumeration of integers (set contaning all numbers in set).

       end

       else

       end

     end

     # Converts the different ways to specify constant sets in the interface

     # to an instance of Gecode::Raw::IntSet. The different forms accepted are:

     # * Single instance of Fixnum (singleton set).

     # * Range (set containing all numbers in range), treated differently from

     #   other enumerations.

     # * Enumeration of integers (set contaning all numbers in set).

       end

       else

       end

     end

     # Checks whether the specified expression is regarded as a constant set.

     # Returns true if it is, false otherwise.

       return (

          expression.kind_of?(Range) &&        # It's a range.

     end

     # Extracts an array of the values selected for the standard propagation 

     # options (propagation strength and propagation kind) from the hash of

     # parameters given. The options are returned in the order that they are 

     # given when posting constraints to Gecode.      

     end

   end

   # A module that contains utility-methods for extensional constraints.

     # Checks that the specified enumeration is an enumeration containing 

     # one or more tuples of the specified size. It also allows the caller

     # to define additional tests by providing a block, which is given each

     # tuple. If a test fails then an appropriate error is raised.

           "#{tuples.class}."

       end

       end

             "got #{tuple.class}."

         end

             'number of operands in the array.'

         end

       end

     end

   end

 end