freESIntermediateRecombinator.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: freESIntermediateRecombinator.h,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 _freESIntermediateRecombinator_txx
#define _freESIntermediateRecombinator_txx

#include "freESIntermediateRecombinator.h"

namespace FREE
{
  namespace ES
  {


    template <class TIndividual>
    IntermediateRecombinator<TIndividual>
      ::IntermediateRecombinator()
    {
    }

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

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

      for (unsigned int index = 0; index<newIndividual->ObjectiveParameters().size(); index++)
      { //objective parameter
        try
        {
          typename IndividualType::ObjectiveParameterType newValue = 0;
          for (unsigned int count = 0; count<parents.size(); count++)
          {
            newValue += (parents[count]->ObjectiveParameters())[index];
          }
          newValue /= parents.size();

          (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::StrategicParameterType::ParameterValueType newValue = 0;
            for (unsigned int count = 0; count<parents.size(); count++)
            {
              newValue += ((parents[count]->StrategicParameters())[index])->GetValue();
            }
            newValue /= parents.size();

            ((newIndividual->StrategicParameters())[index])->SetValue(newValue);
          }
          catchAllNPassMacro("Error while recombining strategic parameter #"+Convert::ToStr(index)+".");
        }
      }

      return newIndividual;
    }

    template <class TIndividual>
    typename IntermediateRecombinator<TIndividual>::WeightVectorType
    IntermediateRecombinator<TIndividual>
    ::GetWeights(const unsigned long lParentCount) const
    {
      WeightVectorType weights;
      if (lParentCount)
      {
        weights.resize(lParentCount,1.0/lParentCount);
      }
      return weights;
    };

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

#endif

---