solution.h

Go to the documentation of this file.

#ifndef SOLUTION_H_
#define SOLUTION_H_

#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <fitness/fitness.h>
#include <movelem.h>
#include <random.h>

#define FITNESS_MIN -1E9

#ifndef SOLUTION_SOURCE_CODE
    #define SOLUTION_INLINE inline
#else
    #define SOLUTION_INLINE extern inline
#endif

#include "solution_structure_private.h"

typedef struct Solution_ Solution;

SOLUTION_INLINE
Solution Solution_blank(int hpSize){
    Solution retval;
    retval.chain = malloc(sizeof(MovElem) * (hpSize - 1));
    retval.fitness = FITNESS_MIN;
    retval.idle_iterations = 0;
    return retval;
}

SOLUTION_INLINE
Solution Solution_copy(Solution sol, int hpSize){
    Solution retval;
    retval.fitness = sol.fitness;
    retval.idle_iterations = sol.idle_iterations;

    int chainSize = hpSize - 1;

    retval.chain = malloc(sizeof(MovElem) * chainSize);
    memcpy(retval.chain, sol.chain, sizeof(MovElem) * chainSize);

    return retval;
}

SOLUTION_INLINE
void Solution_free(Solution sol){
    free(sol.chain);
}

SOLUTION_INLINE
Solution Solution_random(int hpSize){
    Solution sol;
    int nMovements = hpSize - 1;

    sol.idle_iterations = 0;

    // Generate random MovElem *
    sol.chain = malloc(sizeof(MovElem) * nMovements);
    int i;
    for(i = 0; i < nMovements; i++)
        sol.chain[i] = MovElem_random();

    sol.fitness = FITNESS_MIN;

    return sol;
}

SOLUTION_INLINE
Solution Solution_perturb_relative(Solution perturb, Solution other, int hpSize){
    int chainSize = hpSize - 1;
    int pos1 = urandom_max(chainSize);
    int pos2 = urandom_max(chainSize);

    pos2 = pos1;

    Solution retval = Solution_copy(perturb, hpSize);
    unsigned char elem1 = MovElem_to_number(retval.chain[pos1]);
    unsigned char elem2 = MovElem_to_number(other.chain[pos2]);

    char distance = elem2 - (char) elem1;

    // Generate a number in [0, distance)
    double aux = drandom_x() * (double) distance;

    // Fit the number in the discrete space [0, distance]
    char delta = (char) round(aux);

    retval.chain[pos1] = MovElem_from_number(elem1 + delta);
    retval.idle_iterations = 0;
    retval.fitness = FITNESS_MIN;

    return retval;
}

SOLUTION_INLINE
double Solution_fitness(Solution sol){
    if(sol.fitness < (FITNESS_MIN + 0.1)){
        sol.fitness = FitnessCalc_run2(sol.chain);
    }
    return sol.fitness;
}

SOLUTION_INLINE
void Solution_set_fitness(Solution *sol, double fitness){
    sol->fitness = fitness;
}

SOLUTION_INLINE
int Solution_idle_iterations(Solution sol){
    return sol.idle_iterations;
}

SOLUTION_INLINE
void Solution_inc_idle_iterations(Solution *sol){
    sol->idle_iterations++;
}


SOLUTION_INLINE
const MovElem *Solution_chain(Solution sol){
    return (const MovElem *) sol.chain;
}


#endif