void run_sort_algorithms(t_info *info) { t_algo *best; t_algo *b_sort; t_algo *s_sort; t_algo *d_sort; b_sort = new_algo(info); s_sort = new_algo(info); d_sort = new_algo(info); info->in_count = dumb_sort(d_sort, info); compress_ops(d_sort->operations, &info->in_count); best = d_sort; bubble_sort(b_sort, info); compress_ops(b_sort->operations, &b_sort->op_count); if (b_sort->op_count < best->op_count && stack_sorted(b_sort->stack_a)) best = b_sort; split_sort(s_sort, info); print_stacks(s_sort->stack_a, s_sort->stack_b, info); print_steps(s_sort->operations); compress_ops(s_sort->operations, &s_sort->op_count); if (s_sort->op_count < best->op_count && stack_sorted(s_sort->stack_a)) best = s_sort; run_test2(best, info); delete_algo(&b_sort); delete_algo(&s_sort); delete_algo(&d_sort); }
int main(int argc, char* argv[]){ float a = atof(argv[1]); float b = atof(argv[2]); int steps = atoi(argv[3]); print_steps(a, b, steps); return 0; }
TEST_F(avl_tree, DISABLED_show) { steps_t not_found=scan_steps("(-1,1:X);(0,0:X);(1,-1:X);(1,0:O);(1,1:O);(-2,2:O);(2,-2:X);(3,-3:O);(-2,0:X);(-2,3:O);(-2,1:X);(-2,4:O)"); sort_steps(not_found); steps_t writed_steps=scan_steps("(-3,-2:O);(-2,0:X);(-2,2:O);(-2,4:O);(-1,1:X);(0,0:X);(0,1:X);(1,-1:X);(1,0:O);(1,1:O);(2,-2:X);(3,-3:O)"); sort_steps(writed_steps); std::cout<<print_steps(not_found)<<std::endl<<print_steps(writed_steps)<<std::endl; data_t not_found_bin; points2bin(not_found,not_found_bin); std::string not_found_str; bin2hex(not_found_bin,not_found_str); data_t cut_bin(not_found_bin.begin()+2,not_found_bin.end()); std::string cut_str; bin2hex(cut_bin,cut_str); std::cout<<"not_found: "<<not_found_str<<std::endl<<"cut: "<<cut_str<<std::endl; /* bin_index_t ind("D:\\1\\w",34); data_t key; data_t val; std::string key_str; std::string val_str; std::ofstream fs("D:\\1\\w\\key_content.txt"); for(bool r=ind.first(key,val);r;r=ind.next(key,val)) { bin2hex(key,key_str); bin2hex(val,val_str); // std::cout<<"key="<<key_str<<" val="<<val_str<<std::endl; fs<<key_str<<std::endl; } */ }
void run_test2(t_algo *best, t_info *info) { t_info *w_sort; w_sort = weight_sort(info); compress_ops(w_sort->steps, &w_sort->elem_steps); rollback_sort(info); compress_ops(info->steps, &info->elem_steps); if (info->elem_steps < best->op_count && stack_sorted(info->a)) { if (info->elem_steps < w_sort->elem_steps) print_steps(info->steps); else print_steps(w_sort->steps); } else print_steps(best->operations); delete_mask(w_sort); delete_mask(info); }
static void update_steps() { int steps = (int)HealthMetricStepCount; APP_LOG(APP_LOG_LEVEL_DEBUG, "The step count is %u", steps); print_steps(steps); }
int IterativeDeepening::dfs_search(LiteState& current, int& bound, std::stack<LiteState>& path, Timer& timer) { if(!timer.is_still_valid()){ return current.get_g(); } // Perform heuristic evaluation double startTime = omp_get_wtime(); int h = heuristic->calc_h(std::make_shared<LiteState>(current)); heuristic_timer += (omp_get_wtime() - startTime); current.set_h(h); // Uses stack to trace path through state space path.push(current); // Bound check if (current.get_f() > bound){ // Remove this state from the back of the vector path.pop(); //path.erase(path.begin() + path.size() - 1); nodes_rejected++; int f = current.get_f(); state_space.remove(std::shared_ptr<LiteState>(new LiteState(current))); return f; } if (state_space.state_is_goal(current, goals)){ timer.stop_timing_search(); print_steps(path); solved = true; std::cout << "Nodes generated during search: " << nodes_generated << std::endl; std::cout << "Nodes expanded during search: " << nodes_expanded << std::endl; std::cout << "Sequential search took " << timer.get_search_time() << " seconds." << std::endl; std::cout << "Time spent calculating heuristic: " << heuristic_timer << " seconds." << std::endl; return current.get_f(); } nodes_expanded++; int min = Search::protect_goals; const std::vector<Operator>& applicable_operators = get_applicable_ops(current); for (std::size_t i = 0; i < applicable_operators.size(); i++) { const Operator& op = applicable_operators[i]; // Generate successor state, set path cost LiteState child = get_successor(op, current); int new_g = current.get_g() + op.get_cost(); child.set_g(new_g); // Check if state has been visited, if it has check if we have reached it in fewer steps (lower g value) if (state_space.child_is_duplicate(std::shared_ptr<LiteState>(new LiteState(child)))) { nodes_rejected++; continue; } // Record operator int op_id = op.get_num(); child.set_op_id(op_id); nodes_generated++; int t = 0; // Explore child node t = dfs_search(child, bound, path, timer); if (t < min){ min = t; } // Get out of recursion when done. if (solved){ break; } } // We have generated no children that have lead to a solution and are backtracking. // Erase node as we backtrack through state space path.pop(); return min; }