freESRankRecombinator.txx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freESRankRecombinator.txx,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef _freESRankRecombinator_txx
#define _freESRankRecombinator_txx

#include "freESRankRecombinator.h"

namespace FREE
{
  namespace ES
  {


    template <class TIndividual>
    RankRecombinator<TIndividual>
      ::RankRecombinator()
    {
      m_RankDirection = true;
    }

    template <class TIndividual>
    typename RankRecombinator<TIndividual>::IndividualPointer
      RankRecombinator<TIndividual>
      ::Recombine(const ParentSelectionType& parents) const
    {
      if (!(parents.size()>0)) throwExceptionMacro("Error. At least one parent is needed for recombination.");

      ParentSelectionType sortedParents = parents;

      if (m_RankDirection)
      {
        std::sort(sortedParents.begin(), sortedParents.end(), TIndividual::ObjectiveValueIsLesser);
      }
      else
      {
        std::sort(sortedParents.begin(), sortedParents.end(), TIndividual::ObjectiveValueIsGreater);
      };

      IndividualPointer newIndividual = parents[0]->Clone();

      //reset values
      for (unsigned int index = 0; index<newIndividual->ObjectiveParameters().size(); index++)
      { //objective parameter
        (newIndividual->ObjectiveParameters())[index] = 0.0;
      }
      for (unsigned int index = 0; index<newIndividual->StrategicParameters().size(); index++)
      { //strategic parameter
        if ( newIndividual->StrategicParameters().at(index)->GetHandling()!= IndividualType::StrategicParameterType::HDynamic)
        {
            ((newIndividual->StrategicParameters())[index])->SetValue(0.0);
        }
      }

      //calculation of the weightes mean
      for (unsigned int count = 0; count<sortedParents.size(); count++)
      {
        double dW = ComputeWeight(count+1, sortedParents.size());

        for (unsigned int index = 0; index<newIndividual->ObjectiveParameters().size(); index++)
        { //objective parameter
          try
          {
            typename IndividualType::ObjectiveParameterType newValue = (newIndividual->ObjectiveParameters())[index];
            newValue += dW*((sortedParents[count]->ObjectiveParameters())[index]);
            (newIndividual->ObjectiveParameters())[index] = newValue;
          }
          catchAllNPassMacro("Error while recombining objectiv parameter #"+Convert::ToStr(index)+".");
        }

        for (unsigned int index = 0; index<newIndividual->StrategicParameters().size(); index++)
        { //strategic parameter
          if ( newIndividual->StrategicParameters().at(index)->GetHandling()!= IndividualType::StrategicParameterType::HDynamic)
          {
            try
            {
              typename IndividualType::StrategicParameterValueType newValue = ((newIndividual->StrategicParameters())[index])->GetValue();
              newValue += dW*(((sortedParents[count]->StrategicParameters())[index])->GetValue());
              ((newIndividual->StrategicParameters())[index])->SetValue(newValue);
            }
            catchAllNPassMacro("Error while recombining strategic parameter #"+Convert::ToStr(index)+".");
          }
        }
      }

      return newIndividual;
    }

    template <class TIndividual>
    double
    RankRecombinator<TIndividual>
    ::ComputeWeight(const unsigned long lRank, const unsigned long lParentCount) const
    {
      double dSum = 0;

      for (unsigned long index = 0; index < lParentCount; index++)
      {
        dSum += std::log(index+1.0);
      }

      return (log(lParentCount+1.0)-log((double)lRank)) / ((lParentCount*log(lParentCount+1.0)) - dSum);
    };

    template <class TIndividual>
    typename RankRecombinator<TIndividual>::WeightVectorType
    RankRecombinator<TIndividual>
    ::GetWeights(const unsigned long lParentCount) const
    {
      WeightVectorType weights;
      weights.resize(lParentCount);

      for (unsigned long index = 0; index < lParentCount; index++)
      {
        weights[index] = ComputeWeight(index+1, lParentCount);
      }

      return weights;
    };

  } // end of namespace ES
} // end of namespace FREE

#endif

---