void compute_tactus_level(void) {
int first_time, best_min=0, best_max=0;
double tmin, tmax, val, best_val=0.0;
if (verbosity > 1) {
printf("Computing tactus level.\n");
}
tmin = tactus_min;
tmax = tactus_min * tactus_width;
for (first_time = TRUE;
tmax <= tactus_max;
tmax *= tactus_step, tmin *= tactus_step, first_time = FALSE) {
min_pip = dquantize(tmin, 0);
max_pip = dquantize(tmax, 0);
create_pip_score_arrays(min_pip, max_pip);
compute_tactus_scores();
val = evaluate_solution(TACTUS_LEVEL, FALSE);
if (verbosity > 1) {
printf("Trying tactus level range [%5d, %5d]. Score = %8.3f\n",
pip_time * min_pip, pip_time * max_pip, val);
}
if (first_time || val > best_val) {
best_val = val;
best_min = min_pip;
best_max = max_pip;
}
/* now print out the last row of scores */
/*
printf("The last row of the table:\n");
for (i = min_pip; i<= max_pip; i++) {
printf(" ms = %5d score = %7.5f\n", i*pip_time, pip_array[N_pips-1].score[nscore(i)]);
}
*/
free_pip_score_arrays();
}
if (first_time) {
fprintf(stderr,
"%s: Can't compute tactus level, cause tactus_max is too small.\n",
this_program);
exit(1);
}
min_pip = best_min;
max_pip = best_max;
create_pip_score_arrays(min_pip, max_pip);
compute_tactus_scores();
evaluate_solution(TACTUS_LEVEL, TRUE);
if (verbosity > 1) print_beats(TACTUS_LEVEL);
free_pip_score_arrays();
}
unsigned int run_adaptive_search(rectangle stock, rectangle *pieces_cut, int num_pieces_cut, int *track_solution, unsigned int local_function) {
register unsigned int counter, num_solution, index_item_solution;
unsigned int size_track_solution, pivot_index, neighbor_index, neighbor_function;
int **neighborhood;
int mem_solution;
// Dimensão da solução
size_track_solution = 0;
for (counter = 0; counter < num_pieces_cut; ++counter)
if (track_solution[counter] != -1) size_track_solution++;
// Alocando vizinhança da solução
neighborhood = malloc((size_track_solution - 1) * sizeof(int*));
for (counter = 0; counter < size_track_solution - 1; ++counter)
neighborhood[counter] = malloc(size_track_solution * sizeof(int));
// Selecionando pivô para gerar vizinhança de solução
pivot_index = rand() % size_track_solution;
// Gerando vizinhança e verificando melhor solução local
for (num_solution = 0; num_solution < size_track_solution - 1; ++num_solution) {
for (index_item_solution = 0; index_item_solution < size_track_solution; ++index_item_solution) {
neighborhood[num_solution][index_item_solution] = track_solution[index_item_solution];
}
// Executando permuta com o pivot_index
neighbor_index = num_solution < pivot_index ? num_solution : num_solution + 1;
mem_solution = neighborhood[num_solution][neighbor_index];
neighborhood[num_solution][neighbor_index] = track_solution[pivot_index];
neighborhood[num_solution][pivot_index] = mem_solution;
neighbor_function = evaluate_solution(stock, pieces_cut, num_pieces_cut, neighborhood[num_solution], size_track_solution);
if (neighbor_function > local_function) {
local_function = neighbor_function;
for (counter = 0; counter < size_track_solution; ++counter)
track_solution[counter] = neighborhood[num_solution][counter];
for (; counter < num_pieces_cut; ++counter)
track_solution[counter] = - 1;
}
}
// Destruindo vizinhança da solução
for (counter = 0; counter < size_track_solution - 1; ++counter) free(neighborhood[counter]);
free(neighborhood);
return local_function;
}
unsigned int run_grasp_metaheuristic(rectangle *pieces_cut, rectangle *stock, int num_pieces_cut) {
unsigned int lcr_size, objective_function, local_solution;
register unsigned int c_grasp_iter, c_item_solution;
srand(time(NULL));
// Ordenação decrescente [value/(width * length)] das peças
rectangle_selection_sort(pieces_cut, num_pieces_cut);
lcr_size = num_pieces_cut * GRASP_LRC_PARAM;
objective_function = local_solution = 0;
int track_solution[num_pieces_cut], solution[num_pieces_cut];
for (c_grasp_iter = 0; c_grasp_iter < GRASP_LOOP; ++c_grasp_iter) {
local_solution = build_greedy_randomized_solution(pieces_cut, num_pieces_cut, *stock, lcr_size, track_solution);
clean_rectangle(stock);
reset_status_rectangles(pieces_cut, num_pieces_cut);
local_solution = run_adaptive_search(*stock, pieces_cut, num_pieces_cut, track_solution, local_solution);
if (local_solution > objective_function) {
objective_function = local_solution;
for (c_item_solution = 0; c_item_solution < num_pieces_cut; ++c_item_solution)
solution[c_item_solution] = track_solution[c_item_solution];
}
}
evaluate_solution(*stock, pieces_cut, num_pieces_cut, solution, num_pieces_cut);
return objective_function;
}
