FunctionMinEvalOp.cpp

#include <ecf/ECF.h>
#include "FunctionMinEvalOp.h"
#include <vector>
using namespace std;
 
 
void FunctionMinEvalOp::registerParameters(StateP state)
{
    state->getRegistry()->registerEntry("function", (voidP) (new uint(1)), ECF::UINT);
}
 
 
bool FunctionMinEvalOp::initialize(StateP state)
{
    voidP sptr = state->getRegistry()->getEntry("function"); // get parameter value
    iFunction_ = *((uint*) sptr.get()); // convert from voidP to user defined type
 
    voidP lbound_ptr = state->getGenotypes()[0]->getParameterValue(state, "lbound");
    double lbound = *((double*)lbound_ptr.get());
 
 
    return true;
}
 
 
double calculateDistance(double s1[], double s2[])
{
    double d = 0;
    for(uint i = 0; i < 3; i++)
        d += (s1[i] - s2[i]) * (s1[i] - s2[i]);
    d = sqrt(d);
    return d;
}
 
 
FitnessP FunctionMinEvalOp::evaluate(IndividualP individual)
{
    const double c = 300000; // light speed in km/s
 
    // ovo bi GA trebao otkriti:
    double receiver[] = {1, -1, 0.25};
    double receiverTimeError = 0.000001;
 
    // koordinate satelita, x, y, z
    double s1[] = {0, -400, 1000};
    double s2[] = {300, 0, 1000};
    double s3[] = {-600, 0, 1000};
    double s4[] = {0, 700, 1000};
    double* sats[4] = {s1, s2, s3, s4};
 
    // izracunaj udaljenosti
    double d1 = calculateDistance(s1, receiver);
    double d2 = calculateDistance(s2, receiver);
    double d3 = calculateDistance(s3, receiver);
    double d4 = calculateDistance(s4, receiver);
    double dist[4] = {d1, d2, d3, d4};
 
    // izracunaj trajanja putovanja signala
    double signalSendTime = 0;
    double signalTravelTime[4];
    double signalReceiveTime[4];
    for(uint i = 0; i < 4; i++) {
        signalTravelTime[i] = dist[i] / c;
        signalReceiveTime[i] = signalSendTime + signalTravelTime[i] + receiverTimeError;
    }
 
    // dohvati trenutnu jedinku
    FloatingPoint::FloatingPoint* gen = (FloatingPoint::FloatingPoint*) individual->getGenotype().get();
 
    double fitnessValue = 0;
    for(uint i = 0; i < 4; i++) {
        double posError = 
            pow(gen->realValue[0] - sats[i][0], 2) +
            pow(gen->realValue[1] - sats[i][1], 2) +
            pow(gen->realValue[2] - sats[i][2], 2);
        double timeError = 
            // A: bez uzimanja u obzir greske u satu primatelja
            //pow(c * (signalReceiveTime[i] - receiverTimeError - signalSendTime), 2);
            // B: uz racuanje greske u satu primatelja
            pow(c * (signalReceiveTime[i] - gen->realValue[3]/100000 - signalSendTime), 2);
        double satError = posError - timeError;
        fitnessValue += satError * satError;
    }
 
    fitnessValue = sqrt(fitnessValue) / 4;
 
    FitnessP fitness (new FitnessMin);
    fitness->setValue(fitnessValue);
 
    return fitness;
}