////// 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); } }