/** * Calculate table index * * @return {int} table index (range: 0 .. MAX_IDX) * * | 0-5 | 6-7 | 8-10 * | wk (0..63) | wp file (0..3) | wp rank (0..5) */ inline int index(int wk, int wp) { int result = wk + (FILE(wp) << 6) + ((RANK(wp) - 1) << 8); assert(result >= 0 && result < MAX_IDX); assert(FILE(wp) <= 3); assert(RANK(wp) <= 6); return result; }
void open_directory(GNode *directory) { if (FILE(directory)->read == FALSE && read_directory(directory) == FALSE) return; FILE(directory)->open = TRUE; add_directory_content(directory); update_last_line(); print_lines(g_list_next(FILE(directory)->line), last_line, TRUE); }
void remove_watch_directory(GNode *directory, gboolean remove_watch) { CHECK_INOTIFY_ENABLED(); if (FILE(directory)->watch == -1) PRINT_ERROR_INFO("Directory doesn't have a watch associated"); else if (remove_watch && inotify_rm_watch(inotify_descriptor, FILE(directory)->watch) == -1) PRINT_ERRNO_INFO(); else if (g_hash_table_remove(watches_table, &(FILE(directory)->watch)) == FALSE) PRINT_ERROR_INFO("Element removal failed in watches_table"); }
gboolean insert_in_tree(GNode *directory, File *file) { GNode *new_file, *file_ptr, *dir_ptr; int position; if (file->name[0] == '.' && FILE(directory)->show_dotfiles == FALSE) { insert_sorted_in_dotfiles(directory, file); return FALSE; } new_file = insert_sorted_in_tree(directory, file); for (dir_ptr = directory; !G_NODE_IS_ROOT(dir_ptr); dir_ptr = dir_ptr->parent) { if (FILE(dir_ptr)->open == FALSE) return FALSE; } if (FILE(dir_ptr)->open == FALSE) return FALSE; file_ptr = get_previous_file(new_file); position = g_list_position(lines, FILE(file_ptr)->line); lines = g_list_insert(lines, new_file, position + 1); file->line = g_list_nth(lines, position + 1); if (g_list_length(first_line) - g_list_length(last_line) + 1) { if (g_list_previous(first_line) == file->line) first_line = file->line; else if (g_list_next(last_line) == file->line) last_line = file->line; } if (g_list_position(lines, first_line) <= position + 1 && position + 1 <= g_list_position(lines, last_line)) { if (position + 1 < g_list_position(lines, selected_line)) { if (g_list_length(first_line) <= getmaxy(tree_window)) print_lines(first_line, last_line, FALSE); else { first_line = g_list_next(first_line); print_lines(first_line, file->line, FALSE); } } else { if (g_list_length(first_line) > getmaxy(tree_window)) last_line = g_list_previous(last_line); if (g_node_last_sibling(new_file) == new_file) print_lines(g_list_previous(file->line), last_line, FALSE); else print_lines(file->line, last_line, FALSE); } return TRUE; } return FALSE; }
void close_directory(GNode *directory) { GNode *directory_sibling; GList *line_ptr; directory_sibling = get_next_file_not_deepper(directory); for (line_ptr = g_list_next(FILE(directory)->line); line_ptr != NULL && NODE(line_ptr) != directory_sibling; line_ptr = g_list_next(FILE(directory)->line)) lines = g_list_delete_link(lines, line_ptr); FILE(directory)->open = FALSE; update_last_line(); print_lines(g_list_next(FILE(directory)->line), last_line, TRUE); }
void add_directory_content(GNode *directory) { GNode *file_ptr, *directory_sibling; int position; directory_sibling = get_next_file_not_deepper(directory); for (position = g_list_position(lines, FILE(directory)->line) + 1, file_ptr = g_node_first_child(directory); file_ptr != NULL && file_ptr != directory_sibling; position++, file_ptr = get_next_file(file_ptr)) { lines = g_list_insert(lines, file_ptr, position); FILE(file_ptr)->line = g_list_nth(lines, position); } }
void TEST(Meshes2) { ors::Mesh mesh1,mesh2; OpenGL gl; gl.add(drawInit,0); gl.add(ors::glDrawMesh,&mesh1); mesh1.readTriFile(FILE("z.e3.tri")); mesh2.readTriFile(FILE("z.e3.tri")); uint i,m=0; double my=mesh1.V(m,1); for(i=0;i<mesh1.V.d0;i++) if(mesh1.V(i,1)>mesh1.V(m,1)){ m=i; my=mesh1.V(m,1); } mesh2.translate(0,my,0); mesh1.addMesh(mesh2); //mesh1.writeTriFile(("z.e3.tri")); //mesh1.writeOffFile(("z.e3.off")); gl.watch(); }
ObjFunction2 Overall_Optimisation_Configuration_Settings::read_vector_from_file(char const *filename, char const *file_description, const int elements,const int necessary){ ObjFunction2 ObjPnt(elements,1111.0); std::cout << std::endl << file_description << " file ..."; std::ifstream FILE(filename); if( FileExists(filename) ){ std::cout << " OK!"<< std::endl; if(FILE.is_open()){ double buff=0.0; std::vector<double> buff_vec; while(FILE>>buff) buff_vec.push_back(buff); if(buff_vec.size()==ObjPnt.size()){ for (unsigned int i=0; i<ObjPnt.size() ; ++i) ObjPnt[i]=buff_vec[i]; }else ObjPnt= ObjFunction2(elements,buff_vec[0]); FILE.close(); std::cout << "\t"<< file_description<< " read: " << ObjPnt << std::endl; return ObjPnt; }else{
HumanBrain::HumanBrain(int _nrInNodes, int _nrOutNodes, int _nrHiddenNodes, shared_ptr<ParametersTable> _PT) : AbstractBrain(_nrInNodes, _nrOutNodes, _nrHiddenNodes, _PT) { useActionMap = (PT == nullptr) ? useActionMapPL->lookup() : PT->lookupBool("BRAIN_HUMAN-useActionMap"); actionMapFileName = (PT == nullptr) ? actionMapFileNamePL->lookup() : PT->lookupString("BRAIN_HUMAN-actionMapFileName"); if (useActionMap) { // if using an action map, load map with lines of format char output1 output2 output3... file must match brain # of outputs string fileName = actionMapFileName; ifstream FILE(fileName); string rawLine; double readDouble; char readChar; vector<double> action; if (FILE.is_open()) { // if the file named by actionMapFileName can be opened while (getline(FILE, rawLine)) { // keep loading one line from the file at a time into "line" until we get to the end of the file std::stringstream ss(rawLine); ss >> readChar; // pull one char, this will be the key to the map action.clear(); for (int i = 0; i < nrOutNodes; i++) { // pull one double for each output ss >> readDouble; // read one double action.push_back(readDouble); } ss >> actionNames[readChar]; actionMap[readChar] = action; } } else { cout << "\n\nERROR:HumanBrain constructor, unable to open file \"" << fileName << "\"\n\nExiting\n" << endl; exit(1); } }
void add_watch_directory(GNode *directory) { char *path; int watch; CHECK_INOTIFY_ENABLED(); path = get_path(directory); if ((watch = inotify_add_watch(inotify_descriptor, path, IN_CREATE | IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE)) == -1) PRINT_ERRNO_INFO(); else { FILE(directory)->watch = watch; g_hash_table_insert(watches_table, &(FILE(directory)->watch), directory); } free(path); }
void read_in_files(){ std::ifstream FILE(path); std::string str; while(std::getline(FILE,str)){ std::vector<unsigned long long> tmp; unsigned long long i=0; unsigned long long lasti=0; for(;i<str.size();i++){ if(str[i]==',' || i==str.size()-1){ unsigned long long val=std::stoull(str.substr(lasti,i+1-lasti),nullptr,10); tmp.push_back(val); lasti=i+1; } } src_file.push_back(tmp); } FILE.close(); input_freqs=std::vector<double>(src_file[1].size()); std::ifstream FILE2 (input_freqs_path); while(std::getline(FILE2,str)){ int input=std::stoi(str.substr(0,1),nullptr,10); double freq=std::stod(str.substr(2,str.size()-2),nullptr); input_freqs[input]=freq; } FILE2.close(); }
vector<Point> generateCircle(Point center, int radius, const char* filename) { vector<Point> P; for(int x = -radius; x<radius; x++) { int y = round(sqrt(radius*radius-x*x)); P.push_back(Point(center[0]+x,center[1]+y)); } for(int x = radius; x>-radius; x--) { int y = -round(sqrt(radius*radius-x*x)); P.push_back(Point(center[0]+x,center[1]+y)); } if(filename != NULL) { /* save into files */ std::ofstream FILE(filename); for(vector<Point>::const_iterator it = P.begin(); it != P.end(); it++) { FILE << (*it)[0]<<" "<<(*it)[1] <<'\n'; } /* save into files */ } return P; }
vector<PointD> generateSegment(PointD startPoint, PointD endPoint, double step, const char* filename) { vector<PointD> P; //AB: y = a x + b where a = dy/dx and b = yA - a(xA) double dx = endPoint[0] - startPoint[0] , dy = endPoint[1] - startPoint[1]; double x, y; if(dx == 0) //vertical line { x = startPoint[0]; if(startPoint[1]<endPoint[1]) for(y = startPoint[1]; y <= endPoint[1]; y += step) P.push_back(PointD(x,y)); else for(y = startPoint[1]; y >= endPoint[1]; y -= step) P.push_back(PointD(x,y)); } else { double a = dy/dx; double b = startPoint[1] - a*startPoint[0]; if(startPoint[0]<endPoint[0]) for(x = startPoint[0]; x <= endPoint[0]; x += step) P.push_back(PointD(x,a*x+b)); else for(x = startPoint[0]; x >= endPoint[0]; x -= step) P.push_back(PointD(x,a*x+b)); } /* save into files */ std::ofstream FILE(filename); for(vector<PointD>::const_iterator it = P.begin(); it != P.end(); it++) { FILE << (*it)[0]<<" "<<(*it)[1] <<'\n'; } /* save into files */ return P; }
vector<vector<string>> GBCsv::parseCsv(const string& csvPath) { Data data = FILE()->getDataFromFile(csvPath); vector<vector<string>> v = parseCsv(data.getBytes(), data.getSize()); data.clear(); return v; }
int gbupdate_lua_loader(lua_State * L) { static const std::string FILE_EXT = ".lua"; std::string filename(luaL_checkstring(L, 1)); Data chunk; size_t pos = filename.rfind(FILE_EXT); if (pos == filename.length() - FILE_EXT.length()) { filename = filename.substr(0, pos); } pos = filename.find_first_of("."); while (pos != std::string::npos) { filename.replace(pos, 1, "/"); pos = filename.find_first_of("."); } do { GBUpdateInfo * pInfo = GBUpdate::getInstance()->getUpdateInfo(StringUtils::format("src/%s%s", filename.c_str(), FILE_EXT.c_str())); if (!pInfo) break; if (FILE()->isFileExist(pInfo->location)) { chunk = FILE()->getDataFromFile(pInfo->location); break; } } while (false); if (chunk.getBytes()) { LuaStack* stack = LuaEngine::getInstance()->getLuaStack(); stack->luaLoadBuffer(L, (char*)chunk.getBytes(), (int)chunk.getSize(), filename.c_str()); chunk.clear(); } else { CCLOG("can not get file data of %s", filename.c_str()); return 0; } return 1; }
void init_lines(void) { lines = g_list_append(lines, tree_root); FILE(tree_root)->line = lines; selected_line = lines; first_line = lines; update_last_line(); }
void init_ui(char *name) { init_curses(); init_tree(name); init_lines(); print_line(FILE(tree_root)->line); open_directory(tree_root); refresh_screen(); }
void update_directory(GNode *directory) { close_directory(directory); destroy_directory_content(directory); open_directory(directory); if (FILE(directory)->show_dotfiles == TRUE) show_dotfiles(directory); }
std::string SqToStr( int sq ) { char file = FILE(sq); char rank = RANK(sq); char buf[3]; buf[0] = file; buf[1] = rank; buf[2] = '\0'; std::string s = buf; return s; }
void select_previous_line_by_first_letter(char letter) { GList *line_ptr; for (line_ptr = g_list_previous(selected_line); line_ptr != NULL; line_ptr = g_list_previous(line_ptr)) { if (FILE(NODE(line_ptr))->name[0] == letter) { select_line(line_ptr); return; } } }
GNode *search_node_by_name(GNode *directory, char *name) { GNode *file_ptr; for (file_ptr = g_node_first_child(directory); file_ptr != NULL; file_ptr = g_node_next_sibling(file_ptr)) { if (!strcmp(FILE(file_ptr)->name, name)) return file_ptr; } return NULL; }
void GBUpdate::onDownloadSuccess(const DownloadTask& task) { string url = task.requestURL; string path = task.storagePath; string custom = task.identifier; if (custom == "md5") { _downloadList.clear(); vector<vector<string>> v = GBCsv::parseCsv(GBUtils::getExternalPath(custom)); for (unsigned int i = 1; i < v.size(); i++) { string key = v[i][0]; string md5 = v[i][1]; unsigned int size = atoi(v[i][2].c_str()); if (_updateInfos.find(key) == _updateInfos.end() || _updateInfos[key].md5 != md5) { GBUpdateInfo info = { key, md5, _remoteVersion, "", size }; _downloadList[key] = info; } } if (getDownloadTotalSize() > MIN_DOWNLOAD_SIZE && !_isAutoUpdate) { DIRECTOR()->getEventDispatcher()->dispatchCustomEvent(GBUPDATE_EVENT_UPDATE_READY); } else { DIRECTOR()->getEventDispatcher()->dispatchCustomEvent(GBUPDATE_EVENT_UPDATE_START); } } else { if (_downloadList.find(custom) != _downloadList.end()) { Data data = FILE()->getDataFromFile(path); if (data.getBytes()) { auto md5 = new MD5(data.getBytes(), data.getSize()); if (md5->toStr() == _downloadList[custom].md5) { _downloadList[custom].location = GBUtils::getExternalPath(custom); DIRECTOR()->getEventDispatcher()->dispatchCustomEvent(GBUPDATE_EVENT_UPDATED_ONE, &_downloadList[custom]); } else _downloader->createDownloadFileTask(url, path, custom); } else _downloader->createDownloadFileTask(url, path, custom); data.clear(); } } }
void init() { bool success; uint8_t temp[2][64][MAX_IDX]; int step = 0; int unknowns; do { unknowns = 0; success = false; //iterate though all possible positions for (int wk = a1; wk <= h8; wk++) { for (int bk = a1; bk <= h8; bk++) { for (int wp = a2; wp <= h7; wp++) { if (FILE(wp) > 3) { continue; } int idx = index(wk, wp); uint8_t * result_w = &temp[WHITE][bk][idx]; uint8_t * result_b = &temp[BLACK][bk][idx]; if (step == 0) { //initialize KPK_BB[WHITE][idx] = 0; KPK_BB[BLACK][idx] = 0; *result_w = eval(WHITE, wk, bk, wp); *result_b = eval(BLACK, wk, bk, wp); success = true; } else { if (*result_w == UNKNOWN) { unknowns++; *result_w = classify_w(wk, bk, wp, temp); success |= *result_w != UNKNOWN; } if (*result_b == UNKNOWN) { unknowns++; *result_b = classify_b(wk, bk, wp, temp); success |= *result_b != UNKNOWN; } } if (*result_w == WIN) { KPK_BB[WHITE][idx] |= BIT(bk); } if (*result_b == WIN) { KPK_BB[BLACK][idx] |= BIT(bk); } } } } step++; } while (success); std::cout << "Generated KPK bitbase in " << (step - 1) << " steps\n"; std::cout << "Unknown classifications: " << unknowns; std::cout << "\nTesting (K,P,K) = (h3, b7, h2): WIN=" << probe(WHITE, h3, b7, h2); }
void TEST(Meshes3) { ors::Mesh mesh; OpenGL gl; gl.add(drawInit,0); gl.add(ors::glDrawMesh,&mesh); //MeshSetSphere(mesh,0); mesh.readTriFile(FILE("z.e4.tri")); gl.reportSelects=true; gl.watch(); cout <<gl.topSelection->name <<endl; uint i=gl.topSelection->name >> 4; mesh.skin(i); gl.watch(); }
void TEST(Meshes) { OpenGL gl; ors::Mesh mesh; mesh.readStlFile(FILE("../../../data/pr2_model/head_v0/head_pan.stl")); mesh.scale(.001); mesh.writeTriFile(("z.full.tri")); mesh.fuseNearVertices(1e-6); mesh.writeTriFile(("z.e4.tri")); mesh.fuseNearVertices(1e-5); mesh.writeTriFile(("z.e3.tri")); mesh.fuseNearVertices(1e-4); mesh.writeTriFile(("z.e2.tri")); gl.add(drawInit,0); gl.add(ors::glDrawMesh,&mesh); gl.watch(); }
/** the param ARGV[0] was changed such as to be the folder name of the executable (working directory) */ list< map<string, string> >& SimRunner::readInputFile( int ARGC, char **ARGV ) { FileParser Reader; map< string, vector<string> >* pParams; char default_file[15]="quantiNemo.ini"; // check if the name of the settings file is passed if (ARGC == 1) { // if no argument is passed use the default file name // is there a default settings file? ARGV[1] = default_file; ifstream FILE(((string)ARGV[0]+ARGV[1]).c_str()); if(!FILE) { // no default settings file message("\nPlease enter the settings file name: "); cin >> ARGV[1]; }
void usage(void) { fprintf(stderr, "FIDOGATE %s %s %s\n\n", version_global(), PROGRAM, version_local(VERSION) ); fprintf(stderr, "usage: %s [-options]\n\n", PROGRAM); fprintf(stderr, "\ options: -b --news-batch (passed on as -b)\n\ -n --news-mode (passed on as -n)\n\ -f --batch-file FILE (passed on as -f FILE)\n\ -m --maxmsg N (passed on as -m N)\n\ \n\ -h --help this help\n"); exit(0); }
char* StringPosition(Position pos) { char ret[2+1]; // Unsigned so we don't need to check < 0. if(pos > 63) { return strdup("#invalid position"); } if(sprintf(ret, "%c%d", 'a'+FILE(pos), RANK(pos)+1) != 2) { panic("Couldn't string position"); } ret[2] = '\0'; return strdup(ret); }
vector<PointD> generateArc(PointD center, double radius, double angleStart, double angleEnd, const char* filename) { vector<PointD> P; double step = 1/radius; if(angleStart<angleEnd) for(double theta = angleStart; theta<angleEnd; theta += step) P.push_back(PointD(center[0]+radius*sin(theta), center[1]+radius*cos(theta))); else for(double theta = angleEnd; theta<angleStart; theta += step) P.push_back(PointD(center[0]+radius*sin(theta), center[1]+radius*cos(theta))); /* save into files */ std::ofstream FILE(filename); for(vector<PointD>::const_iterator it = P.begin(); it != P.end(); it++) { FILE << (*it)[0]<<" "<<(*it)[1] <<'\n'; } /* save into files */ return P; }
vector<PointD> generateCircle(PointD center, double radius, const char* filename) { vector<PointD> P; /* * x = sin(theta)*r * y = cos(theta)*r */ double step = 1/radius; for(double theta = 0; theta<2*M_PI; theta += step) P.push_back(PointD(center[0]+radius*sin(theta), center[1]+radius*cos(theta))); /* save into files */ /* std::ofstream FILE(filename); std::ostream_iterator<PointD> output_iterator(FILE, "\n"); std::copy(P.begin(), P.end(), output_iterator); */ std::ofstream FILE(filename); for(vector<PointD>::const_iterator it = P.begin(); it != P.end(); it++) { FILE << (*it)[0]<<" "<<(*it)[1] <<'\n'; } /* save into files */ return P; }