int main(void) { int a[SIZE]; // create array a // create data for (size_t i = 0; i < SIZE; ++i) { a[i] = 2 * i; } printf("%s", "Enter a number between 0 and 28: "); int key; // value to locate in array a scanf_s("%d", &key); printHeader(); // Search for key in array a const size_t result = binarySearch(a, key, 0, SIZE - 1); // display results if (result != (size_t)-1) { printf("\n%d found at index %d\n", key, result); } else { printf("\n%d not found\n", key); } return 0; }
void TextTestResult::print (std::ostream &stream) { printHeader (stream); printErrors (stream); printFailures (stream); }
void myLog::openLog(const string& fileName, int mode) { if (logLevel < QUIET_MODE) { open(fileName.c_str(),mode); // fail() returns a null zero when operation fails // rc = (*this).fail(); if ( fail() == 0 ) { logName = fileName; printHeader(0); // insert start time into top of log file } else { cout << "ERROR: Log file " << fileName.c_str() << " could not be opened for write access." << endl; logLevel = QUIET_MODE; } } else { cout << "Logging disabled (QUIET_MODE set)" << endl; } }
void StatTool::printTabular(StatManager * sm) { if (ST_WithHeader) { printHeader(); } std::cout<< sm->getGid()<<ST_Separator; std::cout<< sm->getConcensus()<<ST_Separator; std::cout<< sm->getRpeatCount()<< ST_Separator; std::cout<< sm->meanRepeatL()<<ST_Separator; std::cout<< sm->getSpacerCount()<<ST_Separator; if (!sm->getSpLenVec().empty()) { std::cout<< sm->meanSpacerL()<<ST_Separator; } else { std::cout<<0<<ST_Separator; } if (sm->getSpCovVec().empty()) { std::cout<<0<<ST_Separator; } else { std::cout<< sm->meanSpacerC()<<ST_Separator; } std::cout<< sm->getFlankerCount()<<ST_Separator; if (sm->getFlLenVec().empty()) { std::cout<<0<<ST_Separator; } else { std::cout<< sm->meanFlankerL()<<ST_Separator; } std::cout<<sm->getReadCount()<<std::endl; }
void GerberGenerator::generate() { mOutput.clear(); printHeader(); printApertureList(); printContent(); printFooter(); }
int menu0() { char input[32]; // A simple buffer to store whatever the user types in the menu int optionSelected = -1; // Display the menu to select the region while(optionSelected != EXIT) // This condition makes the menu repeat itself until a valid input is entered { system("cls"); // clears the screen printHeader(); printf("Start patch to RU version\n"); // Converts the read string to int optionSelected = 1; // This variable also tells the program later which one of the "moddedBytes" the program should use when replacing the bytes if (optionSelected == EXIT) { break; } // If the user entered an invalid option, displays a error message if(optionSelected < 1 || optionSelected > 2) { printf("\nInvalid option!\n\n"); system("PAUSE"); } else { break; } } return optionSelected; }
void Spice::saveFile(string filename, Circuit& netList){ ofstream file; file.open(filename.c_str()); // Write if (!file) throw AstranError("Could not save file: " + filename); printHeader (file, "* ", ""); map<string, CellNetlst>::iterator cells_it; for ( cells_it = netList.getCellNetlsts()->begin(); cells_it != netList.getCellNetlsts()->end(); cells_it++ ){ file << ".SUBCKT " << cells_it->first; for ( vector<int>::iterator inouts_it=cells_it->second.getInouts().begin(); inouts_it != cells_it->second.getInouts().end(); inouts_it++ ) file << " " << cells_it->second.getNetName(*inouts_it); file << endl; for(map<string,Inst>::iterator tmp=cells_it->second.getInstances().begin(); tmp!=cells_it->second.getInstances().end(); ++tmp){ file << tmp->first << " "; for(vector<int>::iterator tmp2=tmp->second.ports.begin(); tmp2!=tmp->second.ports.end(); ++tmp2) file << cells_it->second.getNetName(*tmp2) << " "; file << tmp->second.subCircuit << endl; } for(int x=0; x<cells_it->second.size(); x++){ file << cells_it->second.getTrans(x).name << " " << cells_it->second.getNetName(cells_it->second.getTrans(x).drain) << " " << cells_it->second.getNetName(cells_it->second.getTrans(x).gate) << " " << cells_it->second.getNetName(cells_it->second.getTrans(x).source) << " "; if(cells_it->second.getTrans(x).type==PMOS) file << netList.getVddNet() << " PMOS"; else file << netList.getGndNet() << " NMOS"; file << " L=" << cells_it->second.getTrans(x).length << "U W=" << cells_it->second.getTrans(x).width << "U"<< endl; } file << ".ENDS " << cells_it->first << endl << endl; } }
/** Constructor */ IcpdFrm::IcpdFrm( wxWindow* parent ):ICPD_frm( parent ){ wxLog::SetActiveTarget( new wxLogTextCtrl(wx_log)); new Redirector( wx_log, cout, false); new Redirector( wx_log, cerr, true); printHeader(cout, "", ""); string astran_cfg; astran_cfg = "astran.cfg"; wxString astran_path; ::wxGetEnv(wxT("ASTRAN_PATH"), &astran_path); if (wxDirExists(astran_path)) { astran_cfg = string(wxString(astran_path).mb_str()) + "/astran.cfg"; ifstream afile(astran_cfg.c_str()); if(afile) { executeCommand(string("read \"" + astran_cfg + "\"")); } } wxabout = new WxAbout(this); wxrules = new WxRules(this); wxautocell = new WxAutoCell(this); wxcircuit = new WxCircuit(this); wxfp = new WxFP(this); wxpreferences = new WxPreferences(this); refresh(); }
// main function int main(int argc, char *argv[]) { ios::sync_with_stdio(false); // warnings if (argc != 4) { usage(argv); return 0; } // create modified RNA index int qualThreshold, coverageThreshold; qualThreshold = atoi(argv[2]); coverageThreshold = atoi(argv[3]); // read lines printHeader(); if (strcmp(argv[1],"-") == 0) { cerr << "Reading from stdin" << endl; readStream(qualThreshold, coverageThreshold); } else { const char* filename = argv[1]; cerr << "Reading from: " << filename << endl; readFile(filename, qualThreshold, coverageThreshold); } return 0; }
int ApiGen::genContextImpl(const std::string &filename, SideType side) { FILE *fp = fopen(filename.c_str(), "wt"); if (fp == NULL) { perror(filename.c_str()); return -1; } printHeader(fp); std::string classname = m_basename + "_" + sideString(side) + "_context_t"; size_t n = size(); fprintf(fp, "\n\n#include <string.h>\n"); fprintf(fp, "#include \"%s_%s_context.h\"\n\n\n", m_basename.c_str(), sideString(side)); fprintf(fp, "#include <stdio.h>\n\n"); // init function; fprintf(fp, "int %s::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData)\n{\n", classname.c_str()); for (size_t i = 0; i < n; i++) { EntryPoint *e = &at(i); fprintf(fp, "\t%s = (%s_%s_proc_t) getProc(\"%s\", userData);\n", e->name().c_str(), e->name().c_str(), sideString(side), e->name().c_str()); } fprintf(fp, "\treturn 0;\n"); fprintf(fp, "}\n\n"); fclose(fp); return 0; }
int ApiGen::genDecoderHeader(const std::string &filename) { FILE *fp = fopen(filename.c_str(), "wt"); if (fp == NULL) { perror(filename.c_str()); return -1; } printHeader(fp); std::string classname = m_basename + "_decoder_context_t"; fprintf(fp, "\n#ifndef GUARD_%s\n", classname.c_str()); fprintf(fp, "#define GUARD_%s\n\n", classname.c_str()); fprintf(fp, "#include \"IOStream.h\" \n"); fprintf(fp, "#include \"%s_%s_context.h\"\n\n\n", m_basename.c_str(), sideString(SERVER_SIDE)); for (size_t i = 0; i < m_decoderHeaders.size(); i++) { fprintf(fp, "#include %s\n", m_decoderHeaders[i].c_str()); } fprintf(fp, "\n"); fprintf(fp, "struct %s : public %s_%s_context_t {\n\n", classname.c_str(), m_basename.c_str(), sideString(SERVER_SIDE)); fprintf(fp, "\tsize_t decode(void *buf, size_t bufsize, IOStream *stream);\n"); fprintf(fp, "\n};\n\n"); fprintf(fp, "#endif // GUARD_%s\n", classname.c_str()); fclose(fp); return 0; }
void MemoryDebugger::doLookForValue(const s2e::plugins::ExecutionTraceItemHeader &hdr, const s2e::plugins::ExecutionTraceMemory &item) { /* if (!(item.flags & EXECTRACE_MEM_WRITE)) { if ((m_valueToFind && (item.value != m_valueToFind))) { return; } }*/ printHeader(hdr); m_os << " pc=0x" << std::hex << item.pc << " addr=0x" << item.address << " val=0x" << item.value << " size=" << std::dec << (unsigned)item.size << " iswrite=" << (item.flags & EXECTRACE_MEM_WRITE); ModuleCacheState *mcs = static_cast<ModuleCacheState*>(m_events->getState(m_cache, &ModuleCacheState::factory)); const ModuleInstance *mi = mcs->getInstance(hdr.pid, item.pc); std::string dbg; if (m_library->print(mi, item.pc, dbg, true, true, true)) { m_os << " - " << dbg; } m_os << std::endl; }
void IndexFrontEnd::doSearch(){ int docIdsFound; set<EvidenceInfo *, EvidenceMostImportant > foundEvidenceSet; map<std::string, int> foundWords; if (mSearchType == WORDS){ getIndexSearcher().findMatchingTerms(mIndexSearcher.getQuery(), foundWords); printFoundWords(foundWords); } else { docIdsFound = getIndexSearcher().searchDocuments(); printHeader(docIdsFound); int foundEvidences = getIndexSearcher().retrieveEvidences(foundEvidenceSet, mFrom, mAmount); set<EvidenceInfo *>::iterator iter; for (iter = foundEvidenceSet.begin(); iter != foundEvidenceSet.end(); iter++){ printEvidenceInfo(**iter); } printNavigation(foundEvidences); for (iter = foundEvidenceSet.begin(); iter != foundEvidenceSet.end(); iter++){ delete *iter; // *iter = 0; } } }
int main(void) { int arr[SIZE]; int element; int searchKey; int count; for (count = 0; count < SIZE; count++) { arr[count] = 2 * count; } printf("Enter a number between 0 and 28: \n"); scanf("%d", &searchKey); printHeader(); element = binearSearch(arr, searchKey, 0, SIZE - 1); if (element != -1) { printf("\n%dvalue found in array%d\n", searchKey, element); } else { printf("\n%dSearched value not found in array\n", searchKey); } system("pause"); return 0; }
gboolean PrintDialog::printLine(int indent, const char *line) { QRect out_rect; QString out_line; if (!line || !cur_printer_ || !cur_painter_) return FALSE; /* Prepare the tabs for printing, depending on tree level */ out_line.fill(' ', indent * 4); out_line += line; out_rect = cur_painter_->boundingRect(cur_printer_->pageRect(), Qt::TextWordWrap, out_line); if (cur_printer_->pageRect().height() < page_pos_ + out_rect.height()) { if (in_preview_) { // When generating a preview, only generate the first page; // if we're past the first page, stop the printing process. return FALSE; } if (*line == '\0') { // Separator return TRUE; } printHeader(); } out_rect.translate(0, page_pos_); cur_painter_->drawText(out_rect, Qt::TextWordWrap, out_line); page_pos_ += out_rect.height(); return TRUE; }
/* * The temperature page, takes a linked list of structs as input * Should be generated from the JSON */ void tempPage(struct tempList *temps){ //take temp list as parameter //Set up the html file for the table printHeader(); printNavbar(); printAccountNav(); startBody(); divClass("centered"); divClass("content"); //start table printf("<table><caption>"); printf("Recorded temperature measurements for the past 24 hours."); printf("</caption>\n"); //Insert the header row of the table printf("<tr>\n"); printf("<th scope=\"col\">Time Recorded</th>\n"); printf("<th scope=\"col\">Temperature Recorded</th>\n"); printf("</tr>\n"); //Fill the rows of the table with the temperature val while (temps!=NULL){ tableRow(temps->tempTime, temps->tempVal); temps = temps -> next; } //close the table and the rest of the page printf("</table>\n"); endDiv(); endDiv(); endBody(); printFooter(); }
void *sal_malloc(u_int32_t n) { byte *allocated; //iterate through to get to the first free space free_header_t *first = (free_header_t *) memory+free_list_ptr; free_header_t *curr = first; int circle = TRUE; printHeader(curr); while (circle)) { //found a chunk that is bigger than we need if (n <= HEADER_SIZE+curr->size) { //check if we can break down chunks if (n <= HEADER_SIZE+(curr->size)/2) { //break chunk, then salloc again (and hence find that chunk) //TODO this is a bad way i think... splitChunk(curr); allocated = sal_malloc(u_int32_t n/2) //if cannot splt, then five them this bit of memory } else { allocated = (byte *)curr + HEADER_SIZE; } break; //else if we get back around the full circle, nothing is big enough so error } else if (curr == first) {
// main function int main(int argc, char *argv[]) { ios::sync_with_stdio(false); cout.sync_with_stdio(false); // warnings if (argc != 4) { usage(argv); return 0; } int qualThreshold = atoi(argv[2]); int covThreshold = atoi(argv[3]); printHeader(); // read lines if (strcmp(argv[1],"-") == 0) { readStream(qualThreshold, covThreshold); } else { const char* filename = argv[1]; readFile(filename,qualThreshold, covThreshold); } return 0; }
int ApiGen::genFuncTable(const std::string &filename, SideType side) { FILE *fp = fopen(filename.c_str(), "wt"); if (fp == NULL) { perror(filename.c_str()); return -1; } printHeader(fp); fprintf(fp, "#ifndef __%s_%s_ftable_t_h\n", m_basename.c_str(), sideString(side)); fprintf(fp, "#define __%s_%s_ftable_t_h\n", m_basename.c_str(), sideString(side)); fprintf(fp, "\n\n"); fprintf(fp, "static const struct _%s_funcs_by_name {\n", m_basename.c_str()); fprintf(fp, "\tconst char *name;\n" \ "\tvoid *proc;\n" \ "} %s_funcs_by_name[] = {\n", m_basename.c_str()); for (size_t i = 0; i < size(); i++) { EntryPoint *e = &at(i); if (e->notApi()) continue; fprintf(fp, "\t{\"%s\", (void*)%s},\n", e->name().c_str(), e->name().c_str()); } fprintf(fp, "};\n"); fprintf(fp, "static const int %s_num_funcs = sizeof(%s_funcs_by_name) / sizeof(struct _%s_funcs_by_name);\n", m_basename.c_str(), m_basename.c_str(), m_basename.c_str()); fprintf(fp, "\n\n#endif\n"); return 0; }
/* * The login page. * If error evaluates to true, show the user that the login failed */ void loginPage(int error){ //Start of the page printHeader(); printNavbar(); startBody(); divClass("centered"); printBanner(); //begin sign in display printf("<h1>Please sign in below to view the temperature recordings.</h1>\n"); divClass("frame"); divClass("inFrame"); if (error) //If Login Failed printf("<font color=\"#990000\">There was an error, try again.</font>"); printf("<form action=\"\" method=\"get\" onSubmit=\"window.location.reload()\">\n" ); input("text", "user", "Username"); br(); input("password" ,"pass", "Password"); br();br(); printf ("<input type=\"submit\" value=\"Sign In!\" class=\"btn\">\n"); button("./temp-cgi/login.cgi", "float-right", "Sign Up!"); printf("</form>\n"); //End login form and fill out the rest of the page endDiv(); endDiv(); endDiv(); endBody(); printFooter(); }
static void msBedPrintTable(struct bed *bedList, struct hash *erHash, char *itemName, char *expName, float minScore, float maxScore, float stepSize, int base, void(*printHeader)(struct bed *bedList, struct hash *erHash, char *item), void(*printRow)(struct bed *bedList,struct hash *erHash, int expIndex, char *expName, float maxScore, enum expColorType colorScheme), void(*printKey)(float minVal, float maxVal, float size, int base, struct rgbColor(*getColor)(float val, float max, enum expColorType colorScheme), enum expColorType colorScheme), struct rgbColor(*getColor)(float val, float max, enum expColorType colorScheme), enum expColorType colorScheme) /* prints out a table from the data present in the bedList */ { int i,featureCount=0; if(bedList == NULL) errAbort("hgc::msBedPrintTable() - bedList is NULL"); featureCount = slCount(bedList); /* time to write out some html, first the table and header */ if(printKey != NULL) printKey(minScore, maxScore, stepSize, base, getColor, colorScheme); printf("<p>\n"); printf("<basefont size=-1>\n"); printf("<table bgcolor=\"#000000\" border=\"0\" cellspacing=\"0\" cellpadding=\"1\"><tr><td>"); printf("<table bgcolor=\"#fffee8\" border=\"0\" cellspacing=\"0\" cellpadding=\"1\">"); printHeader(bedList, erHash, itemName); for(i=0; i<bedList->expCount; i++) { printRow(bedList, erHash, i, expName, maxScore, colorScheme); } printf("</table>"); printf("</td></tr></table>"); printf("</basefont>"); }
int main(){ int i; // Read in the input glass char filename[100] = "glass.std"; printf("Reading: %s\n", filename); tipsy* tipsyIn = readTipsyStd(filename); // Set attributes not set by readTipsy tipsyIn->attr->xmin = -0.5; tipsyIn->attr->xmax = 0.5; tipsyIn->attr->ymin = -0.5; tipsyIn->attr->ymax = 0.5; tipsyIn->attr->zmin = -0.5; tipsyIn->attr->zmax = 0.5; printf("Input "); printHeader(tipsyIn->head); printAttr(tipsyIn->attr); printf("=================================================\n"); // Create 1/8x compressed glass printf("\nCreating 1/8x compressed glass:\n"); tipsy* glass8f = tipsyClone(tipsyIn); tipsyScaleExpand(glass8f, 2, 2, 2); tipsyCenter(glass8f); printHeader(glass8f->head); printAttr(glass8f->attr); printf("=================================================\n"); writeTipsyStd("glass8f.std", glass8f); // Tile the 1/8x compressed glass to 28x2x2 printf("\nTiling Shocktube:\n"); tipsy* rcrShock = tipsyClone(glass8f); tipsyTesselate(rcrShock, 14, 1, 1); // creates 28x2x2 printf("\nCentering:\n"); tipsyCenter(rcrShock); printf("\nEditing Velocities:\n"); for (i=0; i<rcrShock->head->nsph; i++){ if (rcrShock->gas[i].pos[AXIS_X] < 0.0) rcrShock->gas[i].vel[AXIS_X] = -1; else if (rcrShock->gas[i].pos[AXIS_X] > 0.0) rcrShock->gas[i].vel[AXIS_X] = 1; } printHeader(rcrShock->head); printAttr(rcrShock->attr); writeTipsyStd("RCRShock1.std", rcrShock); // Cleanup tipsyDestroy(tipsyIn); tipsyDestroy(glass8f); tipsyDestroy(rcrShock); }
/** * run * Run is the main control body of the program. It first prints the header which * contains directions on how to use the program then enters the paused state * in which the user may edit the population using a cursor controlled by the * arrow keys. If the user presses Enter, the simulation is started and will * continue until the user again presses Enter to pause or Esc to exit. **/ void run(int model[][ROWS]) { printHeader(); //prints directions drawBorder(GRIDCOLOR); //draws a border swapBuff(); int i = COLUMNS/2; //initializes position of cursor to middle of screen int j = ROWS/2; raw_key = 0x1C; //sets raw_key = ENTER while (raw_key != 0x01) { //loops until user hits Esc if (raw_key==0x1C) { //checks for enter pressed raw_key=0; waitVRetrace(); drawGrid(GRIDCOLOR); //draws grid on screen for edit mode drawSquare(i,j,SELCOLOR); //draws cursor at position on screen while (raw_key!=0x1C && raw_key!=0x01) { //loops until Esc or Enter waitVRetrace(); if (raw_key==0x48) { //up arrow has been pressed raw_key = 0; updateSquare(model,i,j); //erases cursor if (j>0) {j--;} //updates cursor position drawSquare(i,j,SELCOLOR); //draws cursor at new position } if (raw_key==0x50) { //down arrow has been pressed raw_key = 0; updateSquare(model,i,j); if (j<ROWS-1) {j++;} drawSquare(i,j,SELCOLOR); } if (raw_key==0x4B) { //left arrow has been pressed raw_key = 0; updateSquare(model,i,j); if (i>0) {i--;} drawSquare(i,j,SELCOLOR); } if (raw_key==0x4D) { //right arrow has been pressed raw_key = 0; updateSquare(model,i,j); if (i<COLUMNS-1) {i++;} drawSquare(i,j,SELCOLOR); } if (raw_key==0x39) { //spacebar has been pressed raw_key = 0; //flips the life state of current square if (model[i][j]==1) {model[i][j]=0;} else {model[i][j]=1;} } swapBuff(); } //clears raw key if enter was pressed if (raw_key==0x1C) {raw_key=0;} updateSquare(model,i,j); //erases cursor drawGrid(BGCOLOR); //erases grid for simulation mode while(raw_key!=0x01 && raw_key!=0x1C) { //loops until Esc or Enter updateModel(model); //simulates game of life and redraws squares waitVRetrace(); swapBuff(); } } } }
int main(int argc, char **argv) { int inputs; /* Number of inputs into the neural network */ getCommandLine(&inputs, argc, argv); printHeader(inputs); printSet(inputs); }
void start() { #ifdef WIN32 assert(QueryPerformanceFrequency(&g_llFrequency) != 0); #endif startTime = osQueryPerfomance(); prevTime = startTime; printHeader(); }
void TextOutputter::write() { printHeader(); m_stream << endl; printFailures(); m_stream << endl; }
void recoverOldExtention(const char *fileName, secureHeader * sHeader){ char * newFilePath = get_only_path_copy(fileName); newFilePath = (char*) myRealloc(newFilePath, strlen(newFilePath) + strlen(sHeader->fileName) + 1); strcat(newFilePath, sHeader->fileName); printHeader(sHeader); fprintf(stderr, "newFile is %s", newFilePath); rename(fileName, newFilePath); myFree(newFilePath); }
void uniqSize(char *ooDir, char *agpFile, char *glFile, char *altFile) /* Figure out unique parts of genome from all the * gold.22 files in ooDir */ { struct fileInfo *chromDirs, *chromEl; struct fileInfo *contigDirs, *contigEl; char subDir[512]; struct chromInfo *ciList = NULL, *ci, *ciTotal; chromDirs = listDirX(ooDir, "*", FALSE); for (chromEl = chromDirs; chromEl != NULL; chromEl = chromEl->next) { char *chromName = chromEl->name; int dirNameLen = strlen(chromName); if (dirNameLen > 0 && dirNameLen <= 2 && chromEl->isDir) { struct chromInfo *ctgList = NULL, *ctg; sprintf(subDir, "%s/%s", ooDir, chromName); contigDirs = listDirX(subDir, "NT*", FALSE); for (contigEl = contigDirs; contigEl != NULL; contigEl = contigEl->next) { if (contigEl->isDir) { int nSize, uSize; char *contigName = contigEl->name; char fileName[512]; sprintf(fileName, "%s/%s/%s", subDir, contigName, agpFile); if (!fileExists(fileName) && altFile != NULL) sprintf(fileName, "%s/%s/%s", subDir, contigName, altFile); if (fileExists(fileName)) { ctg = oneContigInfo(fileName); slAddHead(&ctgList, ctg); getSizes(fileName, &uSize, &nSize); sprintf(fileName, "%s/%s/%s", subDir, contigName, glFile); if (fileExists(fileName)) addStretchInfo(fileName, ctg); } else { warn("No %s in %s/%s", agpFile, subDir, contigName); } } } slFreeList(&contigDirs); ci = combineChromInfo(ctgList, chromName); slAddHead(&ciList, ci); } } slReverse(&ciList); printHeader(stdout); for (ci = ciList; ci != NULL; ci = ci->next) printChromInfo(ci, stdout); ciTotal = combineChromInfo(ciList, "total"); printChromInfo(ciTotal, stdout); }
/** * \brief Main function * \details -- * \param int argc * \param char const** argv * \return \e int */ int main( int argc, char const** argv ) { /*------------------------------------------------*/ /* 1) read command line arguments */ /*------------------------------------------------*/ size_t backup_start = 0; size_t backup_end = 0; size_t backup_step = 0; readArgs(argc, argv, backup_start, backup_end, backup_step); /*------------------------------------------------*/ /* 2) print header */ /*------------------------------------------------*/ printHeader(); /*------------------------------------------------*/ /* 3) recover the simulation state at each backup */ /*------------------------------------------------*/ std::ofstream file("./statistics/SL_diversity.txt", std::ios::out | std::ios::trunc); file << "backup SpA SpB\n"; size_t current_step = backup_start; while (current_step <= backup_end) { std::cout << "> Working with backup " << current_step << " ...\n"; /*----------------------------------------*/ /* 3.1) Open the backups */ /*----------------------------------------*/ Parameters* parameters = new Parameters(current_step); Simulation* simulation = new Simulation(parameters, current_step, false); simulation->initialize(FROM_BACKUP); /*----------------------------------------*/ /* 3.2) Compute SL diversity and write it */ /*----------------------------------------*/ double Sp_A = 0.0; double Sp_B = 0.0; double depth = (double)current_step-simulation->get_phylogenetic_tree()->get_common_ancestor_age(); simulation->get_phylogenetic_tree()->compute_common_ancestor_SL_repartition(Sp_A, Sp_B); if (Sp_A != -1.0 && Sp_B != -1.0) { file << current_step << " " << Sp_A << " " << Sp_B << " " << depth << "\n"; } /*----------------------------------------*/ /* 3.3) Free memory */ /*----------------------------------------*/ delete simulation; simulation = NULL; delete parameters; parameters = NULL; current_step += backup_step; } file.close(); return EXIT_SUCCESS; }
int main() { printHeader(); insert_increasing< S1 >(); insert_increasing< S2 >(); insert_increasing< S3 >(); insert_decreasing< S1 >(); insert_decreasing< S2 >(); insert_decreasing< S3 >(); insert_random< S1 >(); insert_random< S2 >(); insert_random< S3 >(); index_operator_increasing< S1 >(); index_operator_increasing< S2 >(); index_operator_increasing< S3 >(); index_operator_decreasing< S1 >(); index_operator_decreasing< S2 >(); index_operator_decreasing< S3 >(); index_operator_random< S1 >(); index_operator_random< S2 >(); index_operator_random< S3 >(); find< S1 >(); find< S2 >(); find< S3 >(); erase_increasing< S1 >(); erase_increasing< S2 >(); erase_increasing< S3 >(); erase_decreasing< S1 >(); erase_decreasing< S2 >(); erase_decreasing< S3 >(); erase_random< S1 >(); erase_random< S2 >(); erase_random< S3 >(); random_operations< S1 >(); random_operations< S2 >(); random_operations< S3 >(); std::cout << "OK" << std::endl; #if defined _MSC_VER system( "pause" ); #endif return 0; }