Container-Relocation/evaluation.cpp at main · bastifwp/Container-Relocation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include<bits/stdc++.h>

#include "global.h"

using namespace std;

void apply_chosen_heuristic(vector<vector<int>> &yard, vector<int> &stack_position, int origin_stack, int choosed){
    int destiny_stack;

    //Heurística space
    if (choosed == 1){
        destiny_stack = myopic_space(yard, origin_stack);
    }
    //Heurística RI
    else if(choosed == 2){
        destiny_stack = RI(yard, origin_stack);
    }
    //Heurística RIL
    else if(choosed == 3){

        destiny_stack = RIL(yard, origin_stack);
    }

    //Heurística RI right handed
    else if(choosed == 4){
        destiny_stack = RI_R(yard, origin_stack);
    }

    //Heurística RIL right handed
    else if(choosed == 5){
        destiny_stack = RIL_R(yard, origin_stack);
    }

    //Heurística top_diff
    else if(choosed == 6){
        destiny_stack = top_diff(yard, origin_stack);
    }

    //Heurística rebelde de espacio
    else if(choosed == 7){
        destiny_stack = myopic_min_space(yard, origin_stack);
    }

    //Heurística rebelde RI
    else if(choosed == 8){
        destiny_stack = RI_inverse(yard, origin_stack);
    }

    //Realizamos el movimiento
    //cout << "DESTINY: " << destiny_stack << endl;
    int h_origin = yard[origin_stack].size();
    int c2relocate = yard[origin_stack][h_origin-1];
    yard[origin_stack].pop_back();
    yard[destiny_stack].push_back(c2relocate);
    stack_position[c2relocate] = destiny_stack;

}


void evaluateInd(individuo &ind, vector<vector<int>> &initial_yard, vector<int> &stack_position){

    ind.fobj[0] = 0; ind.fobj[1] = 0;

    //Copiamos variables iniciales para trackear los movimientos
    vector<vector<int>> actual_yard = initial_yard;
    vector<int> actual_positions = stack_position;

    //Inicializamos variables
    int id_to_retrieve = 1;
    int n_containers_actual = n_initial_containers;
    int move_actual = 0;
    int n_moves = ind.moves.size();

    //Hasta que no queden containers
    while(n_containers_actual > 0){

        ind.fobj[0]++;
        int origin_stack = actual_positions[id_to_retrieve];
        int h_origin = actual_yard[origin_stack].size();

        //Si está en el tope lo sacamos
        if(id_to_retrieve == actual_yard[origin_stack][h_origin-1]){
            actual_yard[origin_stack].pop_back();
            actual_positions[id_to_retrieve] = -1;
            id_to_retrieve++;
            n_containers_actual--;
        }

        //Si no es así entonces aplicamos heuristica que toca
        else{

            //Si aun quedan movimientos en la lista, aplicarlos
            if(move_actual < n_moves){
                apply_chosen_heuristic(actual_yard, actual_positions, origin_stack, ind.moves[move_actual]);
                move_actual++;
            }
            //Si no quedan, agregar nuevos movimientos de forma aleatoria
            else{
                int coded_heuristic = apply_random_heuristic(actual_yard, actual_positions, origin_stack);
                ind.moves.push_back(coded_heuristic);
            }

            //Si se acaban los movimentos de la lista y aun quedan container, repetirlos desde el principio
            //move_actual == n_moves-1? move_actual = 0 : move_actual++;
        }
    }

    //Si no se utilizaron todos los movimientos, eliminar los sobrantes
    while(move_actual < n_moves){
        ind.moves.pop_back();
        move_actual++;
    }
}

void evaluatePop(vector<individuo> &pop, vector<vector<int>> &initial_yard, vector<int> &stack_position){

    for (int i = 0; i < params.popsize; i++)
    {
        evaluateInd(pop[i], initial_yard, stack_position);
    }

}