feldtruby 0.3.18 → 0.4.0

data/lib/feldtruby/optimize/objective.rb

@@ -8,7 +8,7 @@ require 'feldtruby/annotations'
 # Make all Ruby objects Annotateable so we can attach information to the 
 # individuals being optimized.
 class Object
-	include FeldtRuby::Annotateable
+  include FeldtRuby::Annotateable
 end
 
 module FeldtRuby::Optimize
@@ -32,370 +32,393 @@ module FeldtRuby::Optimize
 # as the comparator. But the mapper and comparator to be used can, of course,
 # be changed.
 class Objective
-	include FeldtRuby::Logging
+  include FeldtRuby::Logging
 
-	# Current version of this objective. Is updated when the min or max values 
-	# for a sub-objective has been updated or when the weights are changed. 
-	# Candidates are always compared based on the latest version of an objective. 
-	attr_accessor :current_version
+  # Current version of this objective. Is updated when the min or max values 
+  # for a sub-objective has been updated or when the weights are changed. 
+  # Candidates are always compared based on the latest version of an objective. 
+  attr_accessor :current_version
 
-	# A quality mapper maps the goal values of a candidate to a single number.
-	attr_accessor :quality_mapper
+  attr_reader :global_min_values_per_aspect, :global_max_values_per_aspect
 
-	# A comparator compares two or more candidates and ranks them based on their
-	# qualities.
-	attr_accessor :comparator
+  def initialize(qualityAggregator = WeightedSumAggregator.new, 
+    comparator = LowerAggregateQualityIsBetterComparator.new)
+
+    # A quality aggregator maps the goal values of a candidate to a single number.
+    @aggregator = qualityAggregator
+    @aggregator.objective = self
+
+    # A comparator compares two or more candidates and ranks them based on their
+    # qualities.
+    @comparator = comparator
+    @comparator.objective = self
 
-	attr_reader :global_min_values_per_aspect, :global_max_values_per_aspect
+    self.current_version = 0
 
-	def initialize(qualityMapper = nil, comparator = nil)
+    # We set all mins to INFINITY. This ensures that the first value seen will
+    # be smaller, and thus set as the new min.
+    @global_min_values_per_aspect = [Float::INFINITY] * num_goals
 
-		@quality_mapper = qualityMapper || WeightedSumQualityMapper.new
-		@comparator = comparator || Comparator.new
-		@quality_mapper.objective = self
-		@comparator.objective = self
+    # We set all maxs to -INFINITY. This ensures that the first value seen will
+    # be larger, and thus set as the new max.
+    @global_max_values_per_aspect = [-Float::INFINITY] * num_goals
 
-		self.current_version = 0
+    setup_logger_and_distribute_to_instance_variables()
 
-		# We set all mins to INFINITY. This ensures that the first value seen will
-		# be smaller, and thus set as the new min.
-		@global_min_values_per_aspect = [Float::INFINITY] * num_goals
+    # An array to keep the best object per goal.
+    @best_objects = Array.new
 
-		# We set all maxs to -INFINITY. This ensures that the first value seen will
-		# be larger, and thus set as the new max.
-		@global_max_values_per_aspect = [-Float::INFINITY] * num_goals
+  end
 
-		setup_logger_and_distribute_to_instance_variables()
+  # Return the number of goals of this objective.
+  def num_goals
+    @num_goals ||= goal_methods.length
+  end
 
-		# An array to keep the best object per goal.
-		@best_objects = Array.new
+  # Return the names of the goal methods.
+  def goal_methods
+    @goal_methods ||= self.methods.select {|m| is_goal_method?(m)}
+  end
 
-	end
+  # Return true iff the goal method with the given index is a minimizing goal.
+  def is_min_goal?(index)
+    (@is_min_goal ||= (goal_methods.map {|m| is_min_goal_method?(m)}))[index]
+  end
 
-	# Return the number of goals of this objective.
-	def num_goals
-		@num_goals ||= goal_methods.length
-	end
+  # Return true iff the method with the given name is a goal method.
+  def is_goal_method?(methodNameAsSymbolOrString)
+    (methodNameAsSymbolOrString.to_s =~ /^(goal|objective)_(min|max)_([\w_]+)$/) != nil
+  end
 
-	# Return the names of the goal methods.
-	def goal_methods
-		@goal_methods ||= self.methods.select {|m| is_goal_method?(m)}
-	end
+  # Return true iff the method with the given name is a goal method.
+  def is_min_goal_method?(methodNameAsSymbolOrString)
+    (methodNameAsSymbolOrString.to_s =~ /^(goal|objective)_min_([\w_]+)$/) != nil
+  end
 
-	# Return true iff the goal method with the given index is a minimizing goal.
-	def is_min_goal?(index)
-		(@is_min_goal ||= (goal_methods.map {|m| is_min_goal_method?(m)}))[index]
-	end
+  # The candidate objects can be mapped to another object before we call the goal
+  # methods to calc the quality values. Default is no mapping but subclasses
+  # can override this for more complex evaluation schemes.
+  def map_candidate_to_object_to_be_evaluated(candidate)
+    candidate
+  end
+
+  # Weights is a map from goal method names to a number that represents the
+  # weight for that goal. Default is to set all weights to 1.
+  def weights
+    @weights ||= ([1] * num_goals)
+  end
+
+  # Set the weights given a hash mapping each goal method name to a number.
+  # The mapper and/or comparator can use the weights in their calculations.
+  def weights=(goalNameToNumberHash)
+
+    raise "Must be same number of weights as there are goals (#{num_aspects}), but is #{weights.length}" unless weights.length == num_goals
+
+    weights = goal_methods.map {|gm| goalNameToNumberHash[gm]}
+
+    logger.log_value :objective_weights_changed, 
+      {"New weights" => goalNameToNumberHash}, 
+      "Weights updated from #{@weights} to #{weights}"
+
+    inc_version_number
+
+    @weights = weights
+
+  end
+
+  # Return a vector of the "raw" quality values, i.e. the fitness value for each
+  # goal. If we have already calculated the sub-qualities we just return them.
+  # If not we calculate them.
+  def sub_qualities_of(candidate, updateGlobals = true)
+    # Return the sub_qualities if we already have calculated them.
+    sqs = sub_qualities_if_already_calculated?(candidate)
+    return sqs if sqs
+    calculate_sub_qualities_of candidate, updateGlobals
+  end
+
+  # Calculate the sub-qualities from scratch, i.e. by mapping the candidate
+  # to an object to be evaluated and then calculate the value of each goal.
+  def calculate_sub_qualities_of(candidate, updateGlobals = true)
+    obj = map_candidate_to_object_to_be_evaluated(candidate)
+    sub_qualitites = goal_methods.map {|gmethod| self.send(gmethod, obj)}
+    update_global_mins_and_maxs(sub_qualitites, candidate) if updateGlobals
+    sub_qualitites
+  end
 
-	# Return true iff the method with the given name is a goal method.
-	def is_goal_method?(methodNameAsSymbolOrString)
-		(methodNameAsSymbolOrString.to_s =~ /^(goal|objective)_(min|max)_([\w_]+)$/) != nil
-	end
+  # Return a quality value for a given candidate and weights for the whole 
+  # objective for a given candidate. Updates the best candidate if this
+  # is the best seen so far.
+  def quality_of(candidate, weights = self.weights)
 
-	# Return true iff the method with the given name is a goal method.
-	def is_min_goal_method?(methodNameAsSymbolOrString)
-		(methodNameAsSymbolOrString.to_s =~ /^(goal|objective)_min_([\w_]+)$/) != nil
-	end
+    q = quality_in_object(candidate)
+    return q if q
 
-	# The candidate objects can be mapped to another object before we call the goal
-	# methods to calc the quality values. Default is no mapping but subclasses
-	# can override this for more complex evaluation schemes.
-	def map_candidate_to_object_to_be_evaluated(candidate)
-		candidate
-	end
+    sub_qualities = sub_qualities_of(candidate)
 
-	# Weights is a map from goal method names to a number that represents the
-	# weight for that goal. Default is to set all weights to 1.
-	def weights
-		@weights ||= ([1] * num_goals)
-	end
+    qv = update_quality_value_of candidate, sub_qualities, weights
+
+    update_best_candidate candidate, qv
+
+    qv
+
+  end
 
-	# Set the weights given a hash mapping each goal method name to a number.
-	# The mapper and/or comparator can use the weights in their calculations.
-	def weights=(goalNameToNumberHash)
+  # Rank candidates from best to worst. Candidates that have the same quality
+  # are randomly ordered.
+  def rank_candidates(candidates, weights = self.weights)
+    # We first ensure all candidates have calculated sub-qualities, then we
+    # call the comparator. This ensures that the gobals are already correctly
+    # updated on each quality value.
+    candidates.map {|c| sub_qualities_of(c, true)}
+
+    # Now just let the comparator rank the candidates
+    @comparator.rank_candidates candidates, weights
+  end
 
-		raise "Must be same number of weights as there are goals (#{num_aspects}), but is #{weights.length}" unless weights.length == num_goals
+  # Return true iff candidate1 is better than candidate2. Will update their
+  # quality values if they are out of date.
+  def is_better_than?(candidate1, candidate2)
+    @comparator.is_better_than?(candidate1, candidate2)
+  end
 
-		weights = goal_methods.map {|gm| goalNameToNumberHash[gm]}
+  # Return true iff candidate1 is better than candidate2. Will update their
+  # quality values if they are out of date.
+  def hat_compare(candidate1, candidate2)
+    @comparator.hat_compare(candidate1, candidate2)
+  end
 
-		#log_value( :objective_weights_changed, goalNameToNumberHash, 
-		#	"Weights updated from #{@weights} to #{weights}" )
+  # Return true iff candidate1 is better than candidate2 for goal _index_. 
+  # Will update their quality values if they are out of date.
+  def is_better_than_for_goal?(index, candidate1, candidate2)
+    @comparator.is_better_than_for_goal?(index, candidate1, candidate2)
+  end
 
-		inc_version_number
+  # Return the aggregated quality value given sub qualities.
+  def aggregated_quality(subQualities)
+    @aggregator.aggregate_from_sub_qualities(subQualities, weights)
+  end
 
-		@weights = weights
+  def note_end_of_optimization(optimizer)
+    logger.log_data :objective_optimization_ends, {
+      "Best object, aggregated" => @best_candidate,
+      "Quality of best object" => @best_quality_value,
+      "Version" => current_version,
+      "Comparator" => @comparator,
+      "Aggregator" => @aggregator,
+      "Best objects per goal" => @best_objects
+    }, "Objective: Report at end of optimization", true
+  end
 
-	end
+  attr_reader :best_candidate
 
-	# Return a vector of the "raw" quality values, i.e. the fitness value for each
-	# goal.
-	def sub_qualities_of(candidate, updateGlobals = true)
-		obj = map_candidate_to_object_to_be_evaluated(candidate)
-		sub_qualitites = goal_methods.map {|gmethod| self.send(gmethod, obj)}
-		update_global_mins_and_maxs(sub_qualitites, candidate) if updateGlobals
-		sub_qualitites
-	end
+  private
 
-	# Return a quality value for a given candidate and weights for the whole 
-	# objective for a given candidate. Updates the best candidate if this
-	# is the best seen so far.
-	def quality_of(candidate, weights = self.weights)
+  def update_quality_value_of(candidate, subQualities, weights)
+    qv = QualityValue.new subQualities, candidate, self
+    update_quality_value_in_object candidate, qv
+  end
 
-		q = quality_if_up_to_date?(candidate)
-		return q if q
+  def update_best_candidate candidate, qv
+    if @best_candidate == nil || (qv.value < @best_quality_value.value)
+      set_new_best_candidate candidate, qv
+    end
+  end
 
-		sub_qualities = sub_qualities_of(candidate)
+  def set_new_best_candidate candidate, qualityValue
 
-		qv = update_quality_value_of candidate, sub_qualities, weights
+    @best_candidate = candidate
+    @best_quality_value = qualityValue
 
-		update_best_candidate candidate, qv
+    logger.log_data :objective_new_best_candidate, {
+      :candidate => candidate,
+      :quality_value => qualityValue
+    }, "Objective: New best ever found", true
 
-		qv
+  end
 
-	end
+  def inc_version_number
 
-	# Rank candidates from best to worst. Updates the quality value of each
-	# candidate.
-	def rank_candidates(candidates, weights = self.weights)
+    new_version = self.current_version + 1
 
-		# Map each candidate to its sub-qualities without updating the globals.
-		# We will update once for the whole set below.
-		sqvss = candidates.map {|c| sub_qualities_of(c, false)}
+    logger.log_value :objective_version_number, new_version, 
+      "New version of objective: version = #{new_version}"
 
-		# Update the global mins and maxs based on the set of sub-qualities.
-		# Note! This must be done once for the whole set otherwise when we later 
-		# compare the cnadidates based on their quality values they
-		# might be for different versions of the objective.
-		sqvss.each_with_index do |sqvs, i|
-			update_global_mins_and_maxs sqvs, candidates[i]
-		end
+    self.current_version = new_version
 
-		# Update the quality value of each candidate.
-		sqvss.each_with_index do |sqvs, i|
-			update_quality_value_of candidates[i], sqvs, weights
-		end
+  end
 
-		# Now use the comparator to rank the candidates.
-		comparator.rank_candidates candidates, weights
+  # Update the min and max values for each goal in case the values in the
+  # supplied array are outside the previously seen min and max.
+  def update_global_mins_and_maxs subQualityValues, candidate
+    subQualityValues.each_with_index do |sqv,i| 
+      update_global_min_and_max(i, sqv, candidate)
+    end
+  end
 
-	end
+  # Update the global min and max for the goal method with _index_ if
+  # the _qValue_ is less than or
+  def update_global_min_and_max(index, qValue, candidate)
+    min = @global_min_values_per_aspect[index]
+    max = @global_max_values_per_aspect[index]
 
-	# Return true iff candidate1 is better than candidate2. Will update their
-	# quality values if they are out of date.
-	def is_better_than?(candidate1, candidate2)
-		quality_of(candidate1) < quality_of(candidate2)
-	end
+    if qValue < min
 
-	# Return true iff candidate1 is better than candidate2 for goal _index_. 
-	# Will update their quality values if they are out of date.
-	def is_better_than_for_goal?(index, candidate1, candidate2)
-		qv1 = quality_of(candidate1)
-		qv2 = quality_of(candidate2)
-		qv1.sub_quality(index, true) <= qv2.sub_quality(index, true)
-	end
+      @global_min_values_per_aspect[index] = qValue
 
-	def note_end_of_optimization(optimizer)
-		nil
-	end
+      reset_quality_scale candidate, index, :min
 
-	attr_reader :best_candidate
+    end
+    if qValue > max
 
-	private
+      @global_max_values_per_aspect[index] = qValue
 
-	def update_quality_value_of(candidate, subQualities, weights)
+      reset_quality_scale candidate, index, :max
 
-		q = quality_mapper.map_from_sub_qualities(subQualities, weights)
+    end
+  end
 
-		qv = QualityValue.new q, subQualities, candidate, self
+  # Reset the quality scale if the updated min or max value
+  # was the best quality value seen for the goal with given _index_.
+  def reset_quality_scale(candidate, index, typeOfReset)
 
-		update_quality_value_in_object candidate, qv
+    is_min = is_min_goal?(index)
 
-	end
+    if (typeOfReset == :min && is_min) || (typeOfReset == :max && !is_min)
 
-	def update_best_candidate candidate, qv
-		if @best_candidate == nil || (qv < @best_quality_value)
-			set_new_best_candidate candidate, qv
-		end
-	end
+      @best_objects[index] = candidate
 
-	def set_new_best_candidate candidate, qualityValue
+      logger.log_data :objective_better_object_for_goal, {
+        :better_candidate => candidate,
+        :type_of_improvement => typeOfReset
+        }, "Better candidate found for goal #{goal_methods[index]}"
 
-		@best_candidate = candidate
-		@best_quality_value = qualityValue
+      # Reset the best object since we have a new scale
+      @best_candidate = nil
 
-		#log_data :objective_new_best_candidate, {
-		#	:candidate => candidate,
-		#	:quality_value => qualityValue
-		#}, "New best candidate found"
+    end
 
-	end
+    inc_version_number
 
-	def inc_version_number
+  end
 
-		new_version = @current_version + 1
+  def sub_qualities_if_already_calculated?(candidate)
+    qv = quality_in_object candidate
+    !qv.nil? ? qv.sub_qualities : nil
+  end
 
-		#log_value :objective_version_number, new_version, 
-		#	"New version of objective:\n#{self.to_s}"
+  # Get the hash of annotations that we have done to this object.
+  def my_annotations(object)
+    object._annotations[self] ||= Hash.new
+  end
 
-		@current_version = new_version
+  def quality_in_object(object)
+    my_annotations(object)[:quality]
+  end
 
-	end
-
-	# Update the min and max values for each goal in case the values in the
-	# supplied array are outside the previously seen min and max.
-	def update_global_mins_and_maxs subQualityValues, candidate
-		subQualityValues.each_with_index do |sqv,i| 
-			update_global_min_and_max(i, sqv, candidate)
-		end
-	end
-
-	# Update the global min and max for the goal method with _index_ if
-	# the _qValue_ is less than or
-	def update_global_min_and_max(index, qValue, candidate)
-		min = @global_min_values_per_aspect[index]
-		max = @global_max_values_per_aspect[index]
-
-		if qValue < min
-
-			@global_min_values_per_aspect[index] = qValue
-
-			reset_quality_scale candidate, index, :min
-
-		end
-		if qValue > max
-
-			@global_max_values_per_aspect[index] = qValue
-
-			reset_quality_scale candidate, index, :max
-
-		end
-	end
-
-	# Reset the quality scale if the updated min or max value
-	# was the best quality value seen for the goal with given _index_.
-	def reset_quality_scale(candidate, index, typeOfReset)
-
-		is_min = is_min_goal?(index)
-
-		if (typeOfReset == :min && is_min) || (typeOfReset == :max && !is_min)
-
-			@best_objects[index] = candidate
-
-			#log_data :objective_better_object_for_goal, {
-			#	:better_candidate => candidate,
-			#	:type_of_improvement => typeOfReset
-			#	}, "Better object found for goal #{goal_methods[i]}"
-
-			# Reset the best object since we have a new scale
-			@best_candidate = nil
-
-		end
-
-		inc_version_number
-
-	end
-
-	# Check if a candidates quality value according to this objective is
-	# up to date with the latest version of the objective.
-	def quality_if_up_to_date?(candidate)
-		qv = quality_in_object candidate
-		(!qv.nil? && qv.version == current_version) ? qv : nil
-	end
-
-	# Get the hash of annotations that we have done to this object.
-	def my_annotations(object)
-		object._annotations[self] ||= Hash.new
-	end
-
-	def quality_in_object(object)
-		my_annotations(object)[:quality]
-	end
-
-	def update_quality_value_in_object(object, qv)
-		my_annotations(object)[:quality] = qv
-	end
+  def update_quality_value_in_object(object, qv)
+    my_annotations(object)[:quality] = qv
+  end
 end
 
-# A QualityMapper maps a vector of sub-quality values (for each individual goal of
+# A QualityAggregator converts a vector of sub-quality values (for each individual goal of
 # an objective) into a single number on which the candidates can be compared.
-class Objective::QualityMapper
-	attr_reader :objective
-
-	def objective=(objective)
-		# Calculate the signs to be used in inverting the max methods later.
-		@signs = objective.goal_methods.map {|gm| objective.is_min_goal_method?(gm) ? 1 : -1}
-		@objective = objective
-	end
-
-	# Map an array of _sub_qualities_ to a single number given an array of weights.
-	# This default class just sums the quality values regardless of the weights.
-	def map_from_sub_qualities subQualityValues, weights
-		subQualityValues.weighted_sum(@signs)
-	end
+# Not every comparator uses the aggregated value to compare candidates though,
+# but the default one does.
+# This default aggregator is just a sum of the individual qualities where
+# max goals are negated.
+class Objective::QualityAggregator
+  attr_reader :objective
+
+  # Set the objective to use.
+  def objective=(objective)
+    # Calculate the signs to be used in inverting the max methods later.
+    @signs = objective.goal_methods.map {|gm| objective.is_min_goal_method?(gm) ? 1 : -1}
+    @objective = objective
+  end
+
+  # Aggregate an array of _sub_qualities_ into a single number given an array of weights.
+  # This default class just sums the quality values regardless of the weights.
+  def aggregate_from_sub_qualities subQualityValues, weights
+    subQualityValues.weighted_sum(@signs)
+  end
 end
 
-# A WeightedSumMapper sums individual quality values, each multiplied with a
+# A WeightedSumAggregator sums individual quality values, each multiplied with a
 # weight.
-class Objective::WeightedSumQualityMapper < Objective::QualityMapper
-	def map_from_sub_qualities subQualityValues, weights
-		sum = 0.0
-		subQualityValues.each_with_index do |qv, i|
-			sum += (qv * weights[i] * @signs[i])
-		end
-		sum
-	end
+class Objective::WeightedSumAggregator < Objective::QualityAggregator
+  def aggregate_from_sub_qualities subQualityValues, weights
+    sum = 0.0
+    subQualityValues.each_with_index do |qv, i|
+      sum += (qv * weights[i] * @signs[i])
+    end
+    sum
+  end
 end
 
-# A SumOfWeightedGlobalRatios implements Bentley's SWGR multi-objective
+# A SumOfWeightedGlobalRatios is very similar to Bentley's SWGR multi-objective
 # fitness mapping scheme as described in the paper:
 #  P. J. Bentley and J. P. Wakefield, "Finding Acceptable Solutions in the 
 #  Pareto-Optimal Range using Multiobjective Genetic Algorithms", 1997
 #  http://eprints.hud.ac.uk/4052/1/PB_%26_JPW_1997_Finding_Acceptable_Solutions.htm
-# It is a weighted sum of the ratios to the best so far for each goal.
+# with the difference that that lower values indicate better quality.
+# It is the weighted sum of the ratios to the best so far for each goal.
 # One of its benefits is that one need not sort individuals in relation to
 # their peers; the aggregate fitness value is fully determined by the individual
 # and the global min and max values for each objective.
-class Objective::SumOfWeigthedGlobalRatiosMapper < Objective::WeightedSumQualityMapper
-	def ratio(index, value, min, max)
-		return 0.0 if value == nil
-		if objective.is_min_aspect?(index)
-			numerator = max - value
-		else
-			numerator = value - min
-		end
-		numerator.to_f.protected_division_with(max - min)
-	end
-
-	def map_from_sub_qualities subQualityValues, weights
-		goal_mins = objective.global_min_values_per_goal
-		goal_maxs = objective.global_max_values_per_goal
-
-		ratios = subQualityValues.map_with_index do |v, i| 
-			ratio i, v, goal_mins[i], goal_maxs[i]
-		end
-
-		# We cannot reuse the superclass in calculating the weighted sum since
-		# we have already taken the signs into account in the ratio method.
-		sum = 0.0
-		ratios.each_with_index do |r, i|
-			sum += (qv * weights[i])
-		end
-
-		sum / weights.sum.to_f
-	end
+class Objective::SumOfWeigthedGlobalRatios < Objective::WeightedSumAggregator
+  def ratio(index, value, min, max)
+    return 1000.0 if value == nil # We heavily penalize if one sub-quality could not be calculated. Max is otherwise 1.0.
+    if objective.is_min_aspect?(index)
+      numerator = value - min
+    else
+      numerator = max - value
+    end
+    numerator.to_f.protected_division_with(max - min)
+  end
+
+  def aggregate_from_sub_qualities subQualityValues, weights
+    goal_mins = objective.global_min_values_per_goal
+    goal_maxs = objective.global_max_values_per_goal
+
+    ratios = subQualityValues.map_with_index do |v, i| 
+      ratio i, v, goal_mins[i], goal_maxs[i]
+    end
+
+    # We cannot reuse the superclass in calculating the weighted sum since
+    # we have already taken the signs into account in the ratio method.
+    sum = 0.0
+    ratios.each_with_index do |r, i|
+      sum += (qv * weights[i])
+    end
+
+    sum / weights.sum.to_f
+  end
 end
 
 # A Comparator ranks a set of candidates based on their sub-qualities.
 # This default comparator just uses the quality value to sort the candidates, with
-# lower values indicating a better quality.
-class Objective::Comparator
-	attr_accessor :objective
-
-	# Return an array with the candidates ranked from best to worst.
-	# Candidates that cannot be distinghuished from each other are randomly ranked.
-	def rank_candidates candidates, weights
-		candidates.sort_by {|c| objective.quality_of(c, weights).value}
-	end
+# lower values indicating better quality.
+class Objective::LowerAggregateQualityIsBetterComparator
+  attr_accessor :objective
+
+  # Return an array with the candidates ranked from best to worst.
+  # Candidates that cannot be distinghuished from each other are randomly ranked.
+  def rank_candidates candidates, weights
+    candidates.sort_by {|c| objective.quality_of(c, weights).value}
+  end
+
+  def is_better_than?(c1, c2)
+    hat_compare(c1, c2) == 1
+  end
+
+  def is_better_than_for_goal?(index, c1, c2)
+    objective.quality_of(c1).sub_quality(index, true) < objective.quality_of(c2).sub_quality(index, true)
+  end
+
+  def hat_compare(c1, c2)
+    # We change the order since smaller values indicates higher quality
+    objective.quality_of(c2).value <=> objective.quality_of(c1).value
+  end
 end
 
 # Class for representing multi-objective _sub_qualitites_ and their summary
@@ -405,62 +428,66 @@ end
 # they reflect the quality of the candidate for the current version of
 # the objective.
 class QualityValue
-	include Comparable
-
-	attr_reader :value, :sub_qualities, :objective, :version, :candidate
-
-	def initialize(qv, subQvs, candidate, objective)
-		@value, @sub_qualities, @objective = qv, subQvs, objective
-		@candidate = candidate
-		@version = objective.current_version
-	end
-
-	def <=>(other)
-		# This ensures they are ranked according to latest version of objective.
-		ranked = objective.rank_candidates [self.candidate, other.candidate]
-		if ranked.last == self.candidate
-			return 1
-		else
-			return -1
-		end
-	end
-
-	# Return the sub quality value with a given index. Can make sure maximization
-	# goals are mapped as minimization goals if ensureMinimization is true.
-	def sub_quality(index, ensureMinimization = false)
-		return @sub_qualities[index] if !ensureMinimization || @objective.is_min_goal?(index)
-		# Now we now this is a max goal that should be returned as a min goal => invert it.
-		-(@sub_qualities[index])
-	end
-
-	def to_s
-		subqs = sub_qualities.map {|f| f.to_significant_digits(4)}
-		"%.3g (SubQs = #{subqs.inspect}, ver. #{version})" % value
-	end
+  include Comparable
+
+  attr_reader :sub_qualities, :objective, :candidate
+
+  def initialize(subQvs, candidate, objective)
+    @sub_qualities, @objective = subQvs, objective
+    @candidate = candidate
+  end
+
+  # Return the aggregated quality value. Will always return an updated value
+  # since it will be recalculated if we have the wrong version.
+  def value
+    return @value if @version && @version == @objective.current_version
+    @version = @objective.current_version
+    @value = @objective.aggregated_quality(@sub_qualities)
+  end
+
+  def <=>(other)
+    return nil unless @objective == other.objective
+    @objective.hat_compare(@candidate, other.candidate)
+  end
+
+  # Return the sub quality value with a given index. Can make sure maximization
+  # goals are mapped as minimization goals if ensureMinimization is true.
+  def sub_quality(index, ensureMinimization = false)
+    return @sub_qualities[index] if !ensureMinimization || @objective.is_min_goal?(index)
+    # Now we now this is a max goal that should be returned as a min goal => invert it.
+    -(@sub_qualities[index])
+  end
+
+  def to_s
+    subqs = sub_qualities.map {|f| f.to_significant_digits(3)}
+    # Note! We ask for the value first which guarantees that we then have a version number.
+    qstr = "#{value.to_significant_digits(4)}"
+    "#{qstr} (SubQs = #{subqs.inspect}, ver. #{@version})"
+  end
 end
 
 # Short hand for when the objective function is given as a block that should be minimized.
 class ObjectiveMinimizeBlock < Objective
-	def initialize(&objFunc)
-		super()
-		@objective_function = objFunc
-	end
-
-	def objective_min_cost_function(candidate)
-		@objective_function.call(*candidate.to_a)
-	end
+  def initialize(&objFunc)
+    super()
+    @objective_function = objFunc
+  end
+
+  def objective_min_cost_function(candidate)
+    @objective_function.call(*candidate.to_a)
+  end
 end
 
 # Short hand for when the objective function is given as a block that should be minimized.
 class ObjectiveMaximizeBlock < Objective
-	def initialize(&objFunc)
-		super()
-		@objective_function = objFunc
-	end
-
-	def objective_max_cost_function(candidate)
-		@objective_function.call(*candidate.to_a)
-	end
+  def initialize(&objFunc)
+    super()
+    @objective_function = objFunc
+  end
+
+  def objective_max_cost_function(candidate)
+    @objective_function.call(*candidate.to_a)
+  end
 end
 
 end