/* * ALGORITHM * * Every test of a constant expression gets turned into a jump. */ int optimise_constant_tests(MODULE *module, FUNCTION *func) { int changed = 0; int i; for (i = 0; i < tree_num_children(func->graph); i++) { NODE *vertex = tree_get_child(func->graph, i); if (!vertex) continue; if (!tree_is_type(vertex, STMT_TEST)) continue; EXPRESSION *expr = tree_get_child(vertex, 0); if (!tree_is_type(expr, EXPR_INTEGER)) continue; int x = CAST_TO_INTEGER(expr)->value; EDGE_TYPE target_type = x ? EDGE_YES : EDGE_NO; NODE *target_succ = get_successor(func->graph, vertex, target_type); /* Replace with a jump. Test vertex remains will be clean up by dead code removal. */ replace_backward(func->graph, vertex, target_succ, 0); changed = 1; } return changed; };
void delete_node(RB_tree *tree, short int key){ RB_node *node = get_node(tree, key); if(node != tree->nil){ RB_node *y, *x; if(node->left == tree->nil || node->right == tree->nil){ y = node; }else{ y = get_successor(node, tree->nil); } if(y->left != tree->nil){ x = y->left; }else{ x = y->right; } x->parent = y->parent; if(y->parent == tree->nil){ tree->root = x; }else if(is_left(y)){ y->parent->left = x; }else{ y->parent->right = x; } if(y != node){ node->key = y->key; } if(y->color == BLACK){ RB_delete_fixup(tree, x); } free(y); } }
void RBTree::remove(int v) { rbnode * n = find(v); if (n == pNil) { return; } rbnode * y = pNil; if (n->lc == pNil || n->rc == pNil) { y = n; } else { y = get_successor(n); n->value = y->value; } rbnode * x = (y->lc == pNil ? y->rc : y->lc); x->parent = y->parent; rbnode * p = y->parent; if (p == pNil) { root = x; } else if (y == p->lc) { p->lc = x; } else { p->rc = x; } if (y->color == BLACK) { remove_fixup(x); } }
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; }