• Main Page
  • Modules
  • Classes
  • Files
  • File List

D:/Projekt/ECF_trunk/examples/COCO/FunctionMinEvalOp.cpp

00001 #include <ecf/ECF.h>
00002 #include "FunctionMinEvalOp.h"
00003 #include <float.h>
00004 
00005 
00006 void FunctionMinEvalOp::registerParameters(StateP state)
00007 {
00008     state->getRegistry()->registerEntry("function", (voidP) (new uint(1)), ECF::UINT);
00009 }
00010 
00011 
00012 bool FunctionMinEvalOp::initialize(StateP state)
00013 {
00014     voidP sptr = state->getRegistry()->getEntry("function"); // get parameter value
00015     iFunction_ = *((uint*) sptr.get()); // convert from voidP to user defined type
00016 
00017     return true;
00018 }
00019 
00020 
00021 FitnessP FunctionMinEvalOp::evaluate(IndividualP individual)
00022 {
00023     // evaluation creates a new fitness object using a smart pointer
00024     // in our case, we try to minimize the function value, so we use FitnessMin fitness (for minimization problems)
00025     FitnessP fitness (new FitnessMin);
00026 
00027     // we define FloatingPoint as the only genotype (in the configuration file)
00028     FloatingPoint::FloatingPoint* gen = (FloatingPoint::FloatingPoint*) individual->getGenotype().get();
00029     // (you can also use boost smart pointers:)
00030     //FloatingPointP gen = boost::dynamic_pointer_cast<FloatingPoint::FloatingPoint> (individual->getGenotype());
00031 
00032     // alternative encoding: Binary Genotype
00033     //Binary::Binary* gen = (Binary::Binary*) individual->getGenotype().get();
00034     //BinaryP gen = boost::dynamic_pointer_cast<Binary::Binary> (individual->getGenotype());
00035 
00036     // we implement the fitness function 'as is', without any translation
00037     // the number of variables is read from the genotype itself (size of 'realValue' vactor)
00038     double realTemp = 0, value = 0;
00039 
00040     switch(iFunction_) {
00041     case 1:
00042         for (uint i = 0; i < gen->realValue.size(); i++){
00043             realTemp = pow((gen->realValue[i] - (i + 1)), 2.);
00044             value += realTemp;
00045         }
00046     break;
00047 
00048     // Schaffer's F6 function
00049     case 2: {
00050         double z = 0;
00051         for(uint i = 0; i < gen->realValue.size(); ++i) {
00052             z += (gen->realValue[i] * gen->realValue[i]);
00053         }
00054         value = 0.5 - (pow(sin(sqrt(z)), 2) - 0.5) / pow(1 + 0.001 * z, 2);
00055         value = -1 * value + 1;
00056     } break;
00057 
00058     // Griewangk
00059     case 3: {
00060         double valueSum = 0, valueProduct = 1, realSum = 0, realProduct = 0;
00061         for (uint i = 0; i < gen->realValue.size(); i++){
00062             realSum = pow(gen->realValue[i], 2.)/4000;
00063             valueSum += realSum;
00064             realProduct = cos(gen->realValue[i] / sqrt((double)(i+1)));
00065             valueProduct *= realProduct;
00066         }
00067         value = valueSum - valueProduct + 1;
00068     } break;
00069 
00070     // Ackley
00071     case 4: {
00072         double realSum = 0, valueSum = 0, realCos = 0, valueCos = 0, pi = 3.141592;
00073         for (uint i = 0; i < gen->realValue.size(); i++){
00074             realSum = pow(gen->realValue[i], 2.);
00075             valueSum += realSum;
00076             realCos = cos (2 * pi * gen->realValue[i]);
00077             valueCos += realCos;
00078         }
00079         value = -20 * exp(-0.2*sqrt(valueSum / gen->realValue.size())) - exp(valueCos / gen->realValue.size()) + 20 + exp(1.);
00080     } break;
00081 
00082     // Rastrigin
00083     case 5: {
00084         double realTemp = 0, pi = 3.141592;
00085         for (uint i = 0; i < gen->realValue.size(); i++) {
00086             realTemp = pow(gen->realValue[i], 2.) - 10 * cos(2 * pi * gen->realValue[i]);
00087             value += realTemp;
00088         }
00089         value = value + 10 * gen->realValue.size();
00090     } break;
00091 
00092     // Rosenbrock
00093     case 6: {
00094         double realTemp = 0;
00095         for (uint i = 0; i < gen->realValue.size() - 1; i++) {
00096             realTemp = 100 * pow(gen->realValue[i + 1] - pow(gen->realValue[i], 2.), 2.) + pow(1 - gen->realValue[i], 2.);
00097             value += realTemp;
00098         }
00099     } break;
00100 
00101     // Schaffer's F7 function
00102     case 7: {
00103         double z = 0;
00104         for(uint i = 0; i < gen->realValue.size(); ++i) {
00105             z += (gen->realValue[i] * gen->realValue[i]);
00106         }
00107         value = pow(z, 0.25) * (1.0 + pow( sin( 50 * pow(z, 0.1)), 2));
00108     } break;
00109 
00110     default:
00111         throw("FunctionMinEvalOp: invalid function index in configuration!");
00112     }
00113 
00114     fitness->setValue(value);
00115     return fitness;
00116 }

Generated on Fri Jul 5 2013 09:34:24 for ECF by  doxygen 1.7.1