int main(int argc, char **argv) { bool good = true; srand(time(NULL)); if (argc < 2) { if (generate_data(RANDOM_SIZE)) goto exit_no_mem; } else { if (read_data(argv[1])) goto exit_bad_input; } good = good && test_init() == 0; good = good && test_append() == 0; good = good && test_duplicate() == 0; good = good && test_links() == 0; good = good && test_prepend() == 0; good = good && test_links() == 0; good = good && test_concat() == 0; good = good && test_links() == 0; good = good && test_break() == 0; good = good && test_links() == 0; good = good && test_insert() == 0; good = good && test_links() == 0; good = good && test_compare() == 0; good = good && test_delete() == 0; good = good && test_links() == 0; good = good && test_clear() == 0; good = good && test_free() == 0; cleanup_data(); return good?EXIT_SUCCESS:EXIT_FAILURE; exit_bad_input: exit_no_mem: cleanup_data(); return EXIT_FAILURE; }
/* ********************************************************************* Expands the tree from the given node until i_max_sim_steps_per_frame is reached ******************************************************************* */ void UniformCostSearch::expand_tree(TreeNode* start_node) { // If the root is terminal, we will not expand any of its children; deal with this // appropriately if (start_node->is_terminal) { set_terminal_root(start_node); return; } std::priority_queue<TreeNode*, std::vector<TreeNode*>, TreeNodeComparer > q; q.push(start_node); int num_simulated_steps = 0; int num_actions = available_actions.size(); m_expanded_nodes = 0; m_generated_nodes = 0; m_pruned_nodes = 0; while(!q.empty()) { // Pop a node to expand TreeNode* curr_node = q.top(); q.pop(); bool leaf_node = (curr_node->v_children.empty()); m_expanded_nodes++; // Expand all of its children (simulates the result) for (int a = 0; a < num_actions; a++) { Action act = available_actions[a]; TreeNode * child; // If re-expanding an internal node, don't creates new nodes if (leaf_node) { m_generated_nodes++; child = new TreeNode(curr_node, curr_node->state, this, act, sim_steps_per_node); // Miquel: Let's fix C = 10000 child->fn += ( m_max_reward - child->accumulated_reward ); // Miquel: add this to obtain Hector's BFS + m_max_reward * (720 - child->depth()) ; // TODO: UniformCostSearch needs to be split into two classes // the new one encapsulating the novelty-based search algorithm if (child->depth() > m_max_depth ) m_max_depth = child->depth(); num_simulated_steps += child->num_simulated_steps; curr_node->v_children.push_back(child); } else { child = curr_node->v_children[a]; if ( !child->is_terminal ) num_simulated_steps += child->num_simulated_steps; } // Don't expand duplicate nodes, or terminal nodes if (!child->is_terminal) { if (! (ignore_duplicates && test_duplicate(child)) ) q.push(child); } } // Stop once we have simulated a maximum number of steps if (num_simulated_steps >= max_sim_steps_per_frame) { break; } } if (q.empty()) std::cout << "Search Space Exhausted!" << std::endl; update_branch_return(start_node); }
int BestFirstSearch::expand_node(TreeNode* curr_node) { int num_simulated_steps = 0; int num_actions = available_actions.size(); bool leaf_node = (curr_node->v_children.empty()); m_expanded_nodes++; if (curr_node->novelty == 1) m_exp_count_novelty1++; else m_exp_count_novelty2++; // Expand all of its children (simulates the result) if (leaf_node) { curr_node->v_children.resize(num_actions); curr_node->available_actions = available_actions; if (m_randomize_successor) std::random_shuffle(curr_node->available_actions.begin(), curr_node->available_actions.end()); } for (int a = 0; a < num_actions; a++) { Action act = curr_node->available_actions[a]; TreeNode * child; // If re-expanding an internal node, don't creates new nodes if (leaf_node) { m_generated_nodes++; child = new TreeNode(curr_node, curr_node->state, this, act, sim_steps_per_node, discount_factor); if (check_novelty_1(child->state)) { update_novelty_table(child->state); child->novelty = 1; m_gen_count_novelty1++; } else { child->novelty = 2; m_gen_count_novelty2++; } child->fn += (m_max_reward - child->discounted_accumulated_reward); // Miquel: add this to obtain Hector's BFS + m_max_reward * (720 - child->depth()) ; child->num_nodes_reusable = curr_node->num_nodes_reusable + num_actions; if (child->depth() > m_max_depth) m_max_depth = child->depth(); num_simulated_steps += child->num_simulated_steps; curr_node->v_children[a] = child; } else { child = curr_node->v_children[a]; m_pruned_nodes++; // This recreates the novelty table (which gets resetted every time // we change the root of the search tree) if (m_novelty_pruning) { if (check_novelty_1(child->state)) { update_novelty_table(child->state); child->novelty = 1; m_gen_count_novelty1++; } else { child->novelty = 2; m_gen_count_novelty2++; } } child->updateTreeNode(); child->fn += (m_max_reward - child->discounted_accumulated_reward); // Miquel: add this to obtain Hector's BFS + m_max_reward * (720 - child->depth()) ; if (child->depth() > m_max_depth) m_max_depth = child->depth(); num_simulated_steps += child->num_simulated_steps; } // // Don't expand duplicate nodes, or terminal nodes if (!child->is_terminal) { if (!(ignore_duplicates && test_duplicate(child))) { if (child->fn != m_max_reward) q_exploitation->push(child); else q_exploration->push(child); } } } curr_node->already_expanded = true; return num_simulated_steps; }
int BestFirstSearch::reuse_branch(TreeNode* node) { int num_simulated_steps = 0; node->updateTreeNode(); update_novelty_table(node->state); queue<TreeNode*> q; q.push(node); while (!q.empty()) { // Pop a node to expand TreeNode* curr_node = q.front(); q.pop(); if (curr_node->depth() > m_reward_horizon - 1) continue; if (!node->v_children.empty()) { for (size_t c = 0; c < node->v_children.size(); c++) { TreeNode* child = curr_node->v_children[c]; // This recreates the novelty table (which gets resetted every time // we change the root of the search tree) if (m_novelty_pruning) { if (check_novelty_1(child->state)) { update_novelty_table(child->state); if (!child->already_expanded) { child->novelty = 1; } } else { if (!child->already_expanded) child->novelty = 2; } } child->updateTreeNode(); child->fn += (m_max_reward - child->discounted_accumulated_reward); // Miquel: add this to obtain Hector's BFS + m_max_reward * (720 - child->depth()) ; //First applicable action if (child->depth() == 1) child->num_nodes_reusable = child->num_nodes(); else child->num_nodes_reusable = curr_node->num_nodes_reusable; if (child->depth() > m_max_depth) m_max_depth = child->depth(); num_simulated_steps += child->num_simulated_steps; // Don't expand duplicate nodes, or terminal nodes if (!child->is_terminal) { if (!(ignore_duplicates && test_duplicate(child))) { if (!child->already_expanded) { if (child->fn != m_max_reward) q_exploitation->push(child); q_exploration->push(child); } else q.push(child); } } } } // // Stop once we have simulated a maximum number of steps // if (num_simulated_steps >= max_sim_steps_per_frame) { // break; // } } return num_simulated_steps; }
void scr_label( void ) { condcode cc; getnum_block gn; labelcb * lb; char linestr[MAX_L_AS_STR]; scan_start += 2; // over dots while( *scan_start == ' ' ) { // may be ...LABEL or ... LABEL scan_start++; // over blanks } if( *scan_start == '\0' ) { // no label? scan_err = true; err_count++; g_err( err_missing_name, "" ); if( input_cbs->fmflags & II_tag_mac ) { utoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); return; } else { gn.argstart = scan_start; gn.argstop = scan_stop; gn.ignore_blanks = 0; cc = getnum( &gn ); // try numeric expression evaluation if( cc == pos ) { // numeric linenumber scan_start = gn.argstart; // start for next token // check if lineno from label matches actual lineno if( input_cbs->fmflags & II_tag_mac ) { if( gn.result != input_cbs->s.m->lineno ) { scan_err = true; err_count++; g_err( err_label_line, gn.resultstr ); utoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); show_include_stack(); return; } } else { if( gn.result != input_cbs->s.f->lineno ) { scan_err = true; err_count++; g_err( err_label_line, gn.resultstr ); utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); show_include_stack(); return; } } if( input_cbs->fmflags & II_tag_mac ) { // numeric macro label no need to store } else { wng_count++; g_warn( wng_label_num ); utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); show_include_stack(); } } else { // no numeric label cc = getarg(); if( cc == pos ) { // label name specefied char * p; char * pt; int len; p = tok_start; pt = token_buf; len = 0; while( len < arg_flen ) { // copy to buffer *pt++ = *p++; len++; } *pt = '\0'; if( len > MAC_NAME_LENGTH ) { err_count++; g_err( err_sym_long, token_buf ); utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); show_include_stack(); token_buf[MAC_NAME_LENGTH] = '\0'; } if( input_cbs->fmflags & II_tag_mac ) { cc = test_duplicate( token_buf, input_cbs->s.m->lineno ); if( cc == pos ) { // ok name and lineno match // nothing to do } else { if( cc == neg ) { // name with different lineno scan_err = true; err_count++; g_err( err_label_dup, token_buf ); utoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); show_include_stack(); return; } else { // new label lb = mem_alloc( sizeof( labelcb ) ); lb->prev = input_cbs->s.m->mac->label_cb; input_cbs->s.m->mac->label_cb = lb; lb->pos = 0; lb->lineno = input_cbs->s.m->lineno; strcpy_s( lb->label_name, sizeof( lb->label_name ), token_buf ); } } } else { cc = test_duplicate( token_buf, input_cbs->s.f->lineno ); if( cc == pos ) { // ok name and lineno match // nothing to do } else { if( cc == neg ) { // name with different lineno scan_err = true; err_count++; g_err( err_label_dup, token_buf ); utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); show_include_stack(); return; } else { // new label lb = mem_alloc( sizeof( labelcb ) ); lb->prev = input_cbs->s.f->label_cb; input_cbs->s.f->label_cb = lb; lb->pos = input_cbs->s.f->pos; lb->lineno = input_cbs->s.f->lineno; strcpy_s( lb->label_name, sizeof( lb->label_name ), token_buf ); } } } } else { scan_err = true; err_count++; g_err( err_missing_name, "" ); if( input_cbs->fmflags & II_tag_mac ) { utoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); return; } } if( *scan_start == ' ' ) { scan_start++; // skip one blank if( *scan_start ) { // rest of line is not empty split_input( buff2, scan_start, false );// split and process next } } scan_restart = scan_stop + 1; return; } }
/* ********************************************************************* Expands the tree from the given node until i_max_sim_steps_per_frame is reached ******************************************************************* */ void BreadthFirstSearch::expand_tree(TreeNode* start_node) { // If the root is terminal, we will not expand any of its children; deal with this // appropriately if (start_node->is_terminal) { set_terminal_root(start_node); return; } queue<TreeNode*> q; q.push(start_node); int num_simulated_steps = 0; int num_actions = available_actions.size(); m_expanded_nodes = 0; m_generated_nodes = 0; m_pruned_nodes = 0; while(!q.empty()) { // Pop a node to expand TreeNode* curr_node = q.front(); q.pop(); bool leaf_node = (curr_node->v_children.empty()); m_expanded_nodes++; // Expand all of its children (simulates the result) if(m_randomize_successor) std::random_shuffle ( available_actions.begin(), available_actions.end() ); if(leaf_node){ curr_node->v_children.resize( num_actions ); curr_node->available_actions = available_actions; } for (int a = 0; a < num_actions; a++) { Action act = available_actions[a]; TreeNode * child; // If re-expanding an internal node, don't creates new nodes if (leaf_node) { m_generated_nodes++; child = new TreeNode(curr_node, curr_node->state, this, act, sim_steps_per_node); // TODO: BreadthFirstSearch needs to be split into two classes // the new one encapsulating the novelty-based search algorithm if (child->depth() > m_max_depth ) m_max_depth = child->depth(); num_simulated_steps += child->num_simulated_steps; curr_node->v_children[a] = child; } else { child = curr_node->v_children[a]; if ( !child->is_terminal ) num_simulated_steps += child->num_simulated_steps; } // Don't expand duplicate nodes, or terminal nodes if (!child->is_terminal) { if (! (ignore_duplicates && test_duplicate(child)) ) q.push(child); } } // Stop once we have simulated a maximum number of steps if (num_simulated_steps >= max_sim_steps_per_frame) { break; } } if (q.empty()) std::cout << "Search Space Exhausted!" << std::endl; update_branch_return(start_node); }
BOOL CMultiApp::InitInstance() { one a; //two b; //b.test(); // testSmartPtrs(); test_duplicate(); /*testFunctors(); test_decorator();*/ /*testLambada(); testTemplates(); testGarbageCollector(); test_tuple();*/ //int tt = 7; //int* a = &tt; //int*b = &tt; //multiThreadTest(); // stringTest(); // stackTest(); // testBFS(); // testDFS(); // binaryTreeTest(); // subProcessTest(); // multiThreadingTest(); // oddEvenTest(); producerConsumerTest(); excel_column_converter(std::string("AA")); excel_column_converter(std::string("27")); // other method for odd even printing ... doesn't work... // { //InitializeCriticalSection(&cs); //_beginthreadex(NULL, NULL, even_thread_cs, 0,0, 0); //_beginthreadex(NULL, NULL, odd_thread_cs, 0,0, 0); //getchar(); //} return TRUE; // InitCommonControlsEx() is required on Windows XP if an application // manifest specifies use of ComCtl32.dll version 6 or later to enable // visual styles. Otherwise, any window creation will fail. INITCOMMONCONTROLSEX InitCtrls; InitCtrls.dwSize = sizeof(InitCtrls); // Set this to include all the common control classes you want to use // in your application. InitCtrls.dwICC = ICC_WIN95_CLASSES; InitCommonControlsEx(&InitCtrls); CWinAppEx::InitInstance(); // Initialize OLE libraries if (!AfxOleInit()) { AfxMessageBox(IDP_OLE_INIT_FAILED); return FALSE; } AfxEnableControlContainer(); EnableTaskbarInteraction(FALSE); // AfxInitRichEdit2() is required to use RichEdit control // AfxInitRichEdit2(); // Standard initialization // If you are not using these features and wish to reduce the size // of your final executable, you should remove from the following // the specific initialization routines you do not need // Change the registry key under which our settings are stored // TODO: You should modify this string to be something appropriate // such as the name of your company or organization SetRegistryKey(_T("Local AppWizard-Generated Applications")); LoadStdProfileSettings(4); // Load standard INI file options (including MRU) InitContextMenuManager(); InitKeyboardManager(); InitTooltipManager(); CMFCToolTipInfo ttParams; ttParams.m_bVislManagerTheme = TRUE; theApp.GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL, RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams); // Register the application's document templates. Document templates // serve as the connection between documents, frame windows and views CSingleDocTemplate* pDocTemplate; pDocTemplate = new CSingleDocTemplate( IDR_MAINFRAME, RUNTIME_CLASS(CMultiDoc), RUNTIME_CLASS(CMainFrame), // main SDI frame window RUNTIME_CLASS(CMultiView)); if (!pDocTemplate) return FALSE; AddDocTemplate(pDocTemplate); // Parse command line for standard shell commands, DDE, file open CCommandLineInfo cmdInfo; ParseCommandLine(cmdInfo); // Dispatch commands specified on the command line. Will return FALSE if // app was launched with /RegServer, /Register, /Unregserver or /Unregister. if (!ProcessShellCommand(cmdInfo)) return FALSE; // The one and only window has been initialized, so show and update it m_pMainWnd->ShowWindow(SW_SHOW); m_pMainWnd->UpdateWindow(); // call DragAcceptFiles only if there's a suffix // In an SDI app, this should occur after ProcessShellCommand return TRUE; }