////// Ordinary DistanceMapper //////////////
R_DimSqueezer::R_DimSqueezer(Rcpp::NumericMatrix r_positions)
{
mapper = 0;
multithreaded = true;
node_no = r_positions.nrow();
dimension_no = r_positions.ncol();
positions = matrix_to_array(r_positions);
distances = inter_node_distances(positions, node_no, dimension_no);
if(positions)
mapper = new DistanceMapper(node_no, dimension_no, positions, distances);
}
/*
adiciona a matriz em closed set checando se ja nao existe
matrix nao liberado pois eh usado por outras funcoes
*/
int add_closed_set(int **matrix, node_queue **queue, int dimension) {
if(matrix == NULL || *matrix == NULL || queue == NULL) return -1;
if(dimension < 2) return -1;
int *array = matrix_to_array(matrix, dimension);
if(array == NULL) return -1;
int i = search(queue, array, dimension*dimension);
if(i == 0) {
free(array);
return -1; // already exist
} else {
add(queue, array);
return 0;
}
}
R_CL_DimSqueezer::R_CL_DimSqueezer(Rcpp::NumericMatrix r_positions)
{
positions = 0;
distances = 0;
mapper = 0;
dimension_no = r_positions.ncol();
node_no = r_positions.nrow();
if(!dimension_no || !node_no)
return;
positions = matrix_to_array(r_positions);
distances = inter_node_distances(positions, node_no, dimension_no);
// At this point we can make a mapper and see how that goes
mapper = new OCL_DistanceMapperManager(node_no, dimension_no, positions, distances);
}
/*
resolve o puzzle
leaf = open list
queue = closed list
0 = deu certo
-1 = esgotou todas as possibilidades ou entrada invalida
*/
int solve_puzzle(int **initial_state, int **final_state, heap_node **leaf, node_queue **queue, int dimension) {
if(initial_state == NULL || final_state == NULL || dimension < 2) return -1;
if(*initial_state == NULL || *final_state == NULL) return -1;
if(leaf == NULL || queue == NULL) return -1;
int *distances = calculate_manhattan_distances(initial_state, final_state, dimension);
if(distances == NULL) return -1;
int sum = manhattan_distances_sum(distances, dimension*dimension);
sum += hamming_heuristic_sum(distances, dimension*dimension);
free(distances);
int *array = matrix_to_array(initial_state, dimension);
if(array == NULL) return -1;
add_priority_queue(leaf, sum, array, dimension*dimension);
int *array_aux = (int*) extract_min(leaf);
if(array_aux == NULL) return -1;
int **x = array_to_matrix(array_aux, dimension);
int i=0;
do {
add_clildren(x, final_state, leaf, queue, dimension);
add_closed_set(x, queue, dimension); // rever necessidade da funcao
if(i > 20000) {
printf("ERROR\n");
return -1;
}
if(check(x, final_state, dimension) == 0) {
free_matrix(x, dimension);
printf("necessary steps: %d\n", i);
return 0;
}
free_matrix(x, dimension);
x = extract_min_checked(leaf, queue, dimension);
i++;
} while(*leaf != NULL);
free_matrix(x, dimension);
return -1;
}
/*
gera os filhos do estado atual
calcula a distancia de manhattan
transforma a matriz permutada em vetor
adiciona na fila de prioridades (open list) que so adiciona se nao existir a mesma
*/
void add_clildren(int **initial_state, int **final_state, heap_node **leaf, node_queue **queue, int dimension) {
if(initial_state == NULL || final_state == NULL || dimension < 2) return;
if(*initial_state == NULL || *final_state == NULL) return;
if(leaf == NULL || queue == NULL) return;
int x=0, y=0;
search_coordinate(initial_state, 0, &x, &y, dimension);
if(swap(initial_state, x, y, x-1, y, dimension) == 0) {
int *distances = calculate_manhattan_distances(initial_state, final_state, dimension);
if(distances == NULL) return;
int sum = manhattan_distances_sum(distances, dimension*dimension);
sum += hamming_heuristic_sum(distances, dimension*dimension);
free(distances);
int *array = matrix_to_array(initial_state, dimension);
if(array == NULL) return;
int i = search(queue, array, dimension*dimension);
if(i != 0) {
add_priority_queue(leaf, sum, array, dimension*dimension);
} else {
free(array);
}
swap(initial_state, x, y, x-1, y, dimension);
}
if(swap(initial_state, x, y, x+1, y, dimension) == 0) {
int *distances = calculate_manhattan_distances(initial_state, final_state, dimension);
if(distances == NULL) return;
int sum = manhattan_distances_sum(distances, dimension*dimension);
sum += hamming_heuristic_sum(distances, dimension*dimension);
free(distances);
int *array = matrix_to_array(initial_state, dimension);
if(array == NULL) return;
int i = search(queue, array, dimension*dimension);
if(i != 0) {
add_priority_queue(leaf, sum, array, dimension*dimension);
} else {
free(array);
}
swap(initial_state, x, y, x+1, y, dimension);
}
if(swap(initial_state, x, y, x, y-1, dimension) == 0) {
int *distances = calculate_manhattan_distances(initial_state, final_state, dimension);
if(distances == NULL) return;
int sum = manhattan_distances_sum(distances, dimension*dimension);
sum += hamming_heuristic_sum(distances, dimension*dimension);
free(distances);
int *array = matrix_to_array(initial_state, dimension);
if(array == NULL) return;
int i = search(queue, array, dimension*dimension);
if(i != 0) {
add_priority_queue(leaf, sum, array, dimension*dimension);
} else {
free(array);
}
swap(initial_state, x, y, x, y-1, dimension);
}
if(swap(initial_state, x, y, x, y+1, dimension) == 0) {
int *distances = calculate_manhattan_distances(initial_state, final_state, dimension);
if(distances == NULL) return;
int sum = manhattan_distances_sum(distances, dimension*dimension);
sum += hamming_heuristic_sum(distances, dimension*dimension);
free(distances);
int *array = matrix_to_array(initial_state, dimension);
if(array == NULL) return;
int i = search(queue, array, dimension*dimension);
if(i != 0) {
add_priority_queue(leaf, sum, array, dimension*dimension);
} else {
free(array);
}
swap(initial_state, x, y, x, y+1, dimension);
}
}
