static point* reader_getpoint(reader* r) { char buf[BUFSIZE]; char seps[] = " ,;\t"; char* token; point* p = &r->p; if (r->f == NULL) return NULL; while (1) { if (fgets(buf, BUFSIZE, r->f) == NULL) { if (r->f != stdin) if (fclose(r->f) != 0) nn_quit("%s: %s\n", r->fname, strerror(errno)); r->f = NULL; return NULL; } if (buf[0] == '#') continue; if ((token = strtok(buf, seps)) == NULL) continue; if (!str2double(token, &p->x)) continue; if ((token = strtok(NULL, seps)) == NULL) continue; if (!str2double(token, &p->y)) continue; r->n++; return p; } }
string_map GSQAligner::get_aligned_contigs(const double& min_score, const double& min_coverage, const string& all_contig_file, const string& hit_contig_file, const string& alignment_file){ ifstream old_contig_fs(all_contig_file.c_str()); ifstream alignment_fs(alignment_file.c_str()); ofstream new_contig_fs(hit_contig_file.c_str()); string line; vector<string> contig_list; logger->debug("Finding the aligned contigs"); num_matches = 0; output_string = "<B>Contig\tStrand\tQuery\tScore\tLength\tCov\tG/P/C</B>\n"; output_string = "<B>" + string_format("%-15s %-8s %-30s %-10s %-15s %-15s %-15s","Contig","Strand","Query","Score","Length","Coverage","G/P/C") + "</B>\n"; output_string += "----------------------------------------------------------------------------------------------------------\n"; while (getline(alignment_fs, line)) { if (line.substr(0,5) == "MATCH"){ vector<string> tokens; tokenize(line, tokens, "\t"); string contig_id = tokens[1].substr(0, tokens[1].length()-1); contig_list.push_back(contig_id); string contig = tokens[1].substr(0,tokens[1].length()-1); string strand = tokens[1].substr(tokens[1].length()-1,1); string query = tokens[2]; string score = tokens[3]; string length = tokens[4]; string cov = tokens[5]; string type = tokens[6]; output_string += string_format("%-15s %-8s %-30s %-10s %-15s %-15s %-15s",contig.c_str(),strand.c_str(),query.c_str(),score.c_str(),length.c_str(),cov.c_str(),type.c_str()) + "\n"; num_matches++; output_string += "\n"; if (type == "P" || type == "C"){ if (str2double(cov) > min_coverage && str2double(score) > min_score) aligned_query_list[query] = contig_id; } } } output_string += "\nLength: cumulative length of scored exons\nCov G/P/C: coverage of contig (G) or cDNA (C) or protein (P), whichever is highest"; alignment_fs.close(); while (getline(old_contig_fs, line)) { if (line.substr(0,1) == ">"){ vector<string> tokens; tokenize(line, tokens, " "); string contig_id = tokens[0].substr(1, tokens[0].length()-1); if (std::find(contig_list.begin(), contig_list.end(), contig_id)!=contig_list.end()){ new_contig_fs << line << endl; getline(old_contig_fs, line); new_contig_fs << line << endl; } } } old_contig_fs.close(); new_contig_fs.close(); return aligned_query_list; }
void PopsDat::parse( const std::string& _Line ) { std::vector<std::string> parts = chopstr( _Line, TOKEN_WHITESPACE.c_str() ); if( parts.size() != 5 ) throw ParseException("POPS: Atom set initial line contains the wrong number of elements"); if( 0 != str2int( parts[0], expectedAtomTypeCount ) || 0 != str2double( parts[1], b12 ) || 0 != str2double( parts[2], b13 ) || 0 != str2double( parts[3], b14 ) || 0 != str2double( parts[4], bOther ) ) throw ParseException("POPS: Invalid value in atom set initial line"); return; }
void MainWindow::on_push_run_clicked() { ui->push_run->setEnabled(true); //Run MonteCarlo Simulation ui->timeBar->setMaximum(ui->t_max->text().toDouble()/Simu->dt); Simu->simuMonteCarlo(ui->t_max->text().toDouble()/Simu->dt+1); //Rune SIVIA //Loading parameters QScriptEngine e; double _box[4][2]; _box[0][0] = (ui->x_min->text()).toDouble(); _box[0][1] = (ui->x_max->text()).toDouble(); _box[1][0] = (ui->y_min->text()).toDouble(); _box[1][1] = (ui->y_max->text()).toDouble(); _box[2][0] = str2double(ui->th_min->text()); _box[2][1] = str2double(ui->th_max->text()); _box[3][0] = (ui->t_min->text()).toDouble(); _box[3][1] = (ui->t_max->text()).toDouble(); if(sivia!=NULL) delete sivia; IntervalVector box(4, _box); //cout << box; QTime t; QString info; t.start(); sivia = new Sivia(*R,ui->epsilonBox->value(), box); double tsiv = t.elapsed()/1000.0; info += "Elapsed time: " + QString::number(tsiv) + " s\n"; info += "\nInitial box:\n\tx:\t[" + QString::number(_box[0][0]) + "," + QString::number(_box[0][1]) + "]\n"; info += "\ty:\t[" + QString::number(_box[1][0]) + "," + QString::number(_box[1][1]) + "]\n"; info += "\ttheta:\t[" + QString::number(_box[2][0]) + "," + QString::number(_box[2][1]) + "]\n"; info += "\tt:\t[" + QString::number(_box[3][0]) + "," + QString::number(_box[3][1]) + "]\n"; info += "\tepsilon: " + QString::number(ui->epsilonBox->value()) + "\n"; info += "\nNumber of boxes: " + QString::number(sivia->Sout.size()+sivia->Sp.size()); info += "\nUnsafe boxes: " + QString::number(sivia->Sp.size()); QMessageBox::information(this,"Sivia report",info); drawAll(); }
void RotLibConvert_Dunbrack_BBInd::readDefinition( StringBuilder& sb, RotamerLibrary& _RotLib ) const { ASSERT( sb.size() >= 67, ParseException, "String too short to parse!!"); StringBuilder resname(3); resname.setTo( sb, 0, 3 ); sb.TruncateLeftBy(18); int pdbCount = sb.parseInt(0,7); if( pdbCount == 0 ) return; double probability = sb.parseDouble(7,8); sb.TruncateLeftBy(37); std::vector<double> importChis; std::vector<std::string> parts = sb.tokenise(); ASSERT( (parts.size() % 2 == 0), ParseException, "Unexpected element count"); for( size_t i = 0; i < parts.size(); i+=2 ) { double chi; ASSERT( 0 == str2double( parts[i], chi ), ParseException, "Error parsing chi def"); importChis.push_back(Maths::DegToRad(chi)); } ASSERT( importChis.size() != 0, ParseException, "No chis found!!"); _RotLib.addRotamer( resname.toString(), importChis, ConstantProbability( probability ) ); }
owner_file_t * loading_owner_file_solution(const int *num_solutions_r, const int *numobj_r, const char *path_file_name){ FILE * solution_file; char *line; char *line_splited; int sol; owner_file_t * solutions_aux; line = Malloc(char, MAX_LINE_SOLUTION_FILE); //Alocating Solution solutions_aux = allocate_file_t(num_solutions_r, numobj_r); //Reading file and set values of objective sol = -1; solution_file = open_file(path_file_name, fREAD); //Removing first line that is collumn fgets(line,MAX_LINE_SOLUTION_FILE,solution_file); while ( fgets(line,MAX_LINE_SOLUTION_FILE,solution_file) != NULL){ sol = sol + 1; //Obtaing index collumn line_splited = strtok (line,"\t"); strcpy(solutions_aux[sol].file_name, line_splited); //Setting number of objectives for (int ob = 0; ob < *numobj_r; ob++){ line_splited = strtok (NULL,"\t"); trim(line_splited); solutions_aux[sol].obj_values[ob] = str2double(line_splited); } } fclose(solution_file); free(line); return solutions_aux; }
void read_constraint_mod(Driver* driver, string line, char tag){//w/grb/ double lb = LB, ub = UB; strvec toks; split(&line, &toks, DELIM); int ntoks = toks.size(); if (ntoks < 1) throw runtime_error(line); string tok0 = toks[0]; if ((ntoks) > 1){ lb = str2double(toks[1]); ub = lb; } if ((ntoks > 2)) ub = str2double(toks[2]); strvec reacs=driver->model->get_reactions(); switch(tag){ case PLUSTAG: read_sto_mod(driver, tok0, lb, ub); break; case MINUSTAG: driver->model->del_element(tok0.substr(1)); break; case ALLTAG:{ for(int i=0;i<reacs.size();i++){ string Rn=reacs[i]; Reaction* reac=driver->model->get_reac(tok0); reac->set_bounds(lb, ub); } break; } // case CTAG: // if (driver->thermo) // ((ThermoLP*)driver->lp)->setConcentration(tok0, lb, ub); // break; // case DG0TAG: // if (driver->thermo) // ((ThermoLP*)driver->lp)->setDeltaG0(tok0.substr(1), lb, ub); // break; // case DGTAG: // tok0 = DELTAG_TAG + tok0.substr(1); default: if(find(reacs.begin(),reacs.end(),tok0)==reacs.end()) throw runtime_error(string("no column ") + tok0); else{ Reaction* reac=driver->model->get_reac(tok0); reac->set_bounds(lb, ub); } } }
ParameterError str2udouble(double *val, const char *str) { ParameterError result = str2double(val, str); if(result != PARAM_OK) return result; if(*val < 0) return PARAM_NEGATIVE_NUMERIC; return PARAM_OK; }
float CVariant::asFloat(float fallback) const { switch (m_type) { case VariantTypeDouble: return (float)m_data.dvalue; case VariantTypeInteger: return (float)m_data.integer; case VariantTypeUnsignedInteger: return (float)m_data.unsignedinteger; case VariantTypeString: return (float)str2double(*m_data.string, fallback); case VariantTypeWideString: return (float)str2double(*m_data.wstring, fallback); default: return fallback; } return fallback; }
void PopsAtomDBType::parse( const std::string& _Line ) { std::vector<std::string> parts = chopstr( _Line, TOKEN_WHITESPACE.c_str() ); if( parts.size() != 6 ) throw ParseException("POPS: Atom set initial line contains the wrong number of elements"); if( 0 != parts[0].compare("ATOM") ) THROW( CodeException, "Only atom lines should ever be fed in here!" ); atomName = parts[1]; resName = parts[2]; int endCol; if( 0 != str2double( parts[3], radius ) || 0 != str2double( parts[4], param ) || 0 != str2int( parts[5], endCol ) ) throw ParseException("POPS: Invalid value in ATOM line"); hydrophilic = (endCol != 0); return; }
bool read_record(Driver* driver, string record){ if (record == CONTINUE) return true; if (isallspace(record)) return false; istringstream is(record, ios::in); string line; int i = 0; do{ ++i; line = line.substr(0, line.find(COMMENT)); if (!line.empty() && !isallspace(line)){ char tag = line[0]; string line2 = line.substr(1); try{ switch(tag){ case OBJTAG: if (driver->target.empty()) read_objective(driver, line2); break; case ARGTAG: if (driver->arg.empty()) driver->set_args(line2); break; //case EXTTAG: // driver->set_externals(line2, true);//externalise the list provided in line2 // break; //case INTTAG: // driver->set_externals(line2, false);//internalise the list provided in line2 // break; case EXTTAG://w/ simply set externals with '\' driver->set_externals_gfa(line2); break; case VMAXTAG: driver->lp->setVMax(str2double(line2)); break; // case TTAG: // if (driver->thermo) ((ThermoLP*)driver->lp)->setTemperature(T0 + str2double(line2)); // break; default: try{ read_constraint(driver, line, tag); } catch(exception &e){;} } } catch(exception &e) { throw runtime_error(string("error in line ") + num2str(i) + ": " + e.what()); } } } while(getline(is, line, NEWLINE)); return true; }
void read_constraint(Driver* driver, string line, char tag){ double lb = LB, ub = UB; strvec toks; split(&line, &toks, DELIM); int ntoks = toks.size(); if (ntoks < 1) throw runtime_error(line); string tok0 = toks[0]; if ((ntoks) > 1){ lb = str2double(toks[1]); ub = lb; } if ((ntoks > 2)) ub = str2double(toks[2]); switch(tag){ case PLUSTAG: read_sto(driver, tok0, lb, ub); break; case MINUSTAG: driver->lp->delRow(tok0.substr(1)); break; case ALLTAG:{ strvec cols = driver->lp->getColNames(); for (strvec::iterator it = cols.begin(); it != cols.end(); ++it) driver->lp->setColBnds(*it, lb, ub); break; } // case CTAG: // if (driver->thermo) // ((ThermoLP*)driver->lp)->setConcentration(tok0, lb, ub); // break; // case DG0TAG: // if (driver->thermo) // ((ThermoLP*)driver->lp)->setDeltaG0(tok0.substr(1), lb, ub); // break; // case DGTAG: // tok0 = DELTAG_TAG + tok0.substr(1); default: if (driver->lp->hasCol(tok0)) driver->lp->setColBnds(tok0, lb, ub); } }
ParameterError str2udouble(double *valp, const char *str, long max) { double value; ParameterError result = str2double(&value, str, max); if(result != PARAM_OK) return result; if(value < 0) return PARAM_NEGATIVE_NUMERIC; *valp = value; return PARAM_OK; }
//------------------------------------------------------------------------------ void GeoDat::dodaj_rek (string ln, string sep, bool nadpisz) { int sepS=sep.size(); if (sepS==0 || ln.size()==0) return; unsigned int licz = 0; unsigned int poz1 = 0; unsigned int poz2 = ln.find(sep,poz1); wektor3d tmp1, tmp2; tmp1.x = str2double(ln.substr(poz1,poz2)); while (poz2<ln.size() && (poz2+sepS)<ln.size() && licz < 5) { poz1 = poz2+sepS; poz2 = ln.find(sep,poz1); switch(licz) { case(0): tmp1.y = str2double(ln.substr(poz1,poz2-poz1));break; case(1): tmp1.z = str2double(ln.substr(poz1,poz2-poz1));break; case(2): tmp2.x = str2double(ln.substr(poz1,poz2-poz1));break; case(3): tmp2.y = str2double(ln.substr(poz1,poz2-poz1));break; case(4): tmp2.z = str2double(ln.substr(poz1,poz2-poz1));break; } licz++; } dodaj_rek(tmp1,tmp2,nadpisz); }
int pop_led_hdf5(hid_t input,state_vector *sv){ int i,count,iy; char tmp_c[200],date[200]; double t[200],t0,t_tmp; unsigned short tmp_i[200]; double x[600], v[600]; hdf5_read(tmp_i,input,"/","","Number of State Vectors",'i'); count = tmp_i[0]; hdf5_read(tmp_c,input,"/","","Reference UTC",'c'); cat_nums(date,tmp_c); str_date2JD(tmp_c,date); t0 = str2double(tmp_c); date[4]='\0'; iy = (int)str2double(date); hdf5_read(t,input,"/","","State Vectors Times",'d'); hdf5_read(x,input,"/","","ECEF Satellite Position",'d'); hdf5_read(v,input,"/","","ECEF Satellite Velocity",'d'); //fprintf(stderr,"%.15f\n",x[3]); for (i=0;i<count;i++){ t_tmp = t[i]/86400.0+t0; sv[i].yr = iy; sv[i].jd = (int)(t_tmp - trunc(t_tmp/1000.0)*1000.0); sv[i].sec = (t_tmp - trunc(t_tmp))*86400.0; sv[i].x = (double)x[i*3]; sv[i].y = (double)x[i*3+1]; sv[i].z = (double)x[i*3+2]; sv[i].vx = (double)v[i*3]; sv[i].vy = (double)v[i*3+1]; sv[i].vz = (double)v[i*3+2]; //fprintf(stderr,"%d %d %.3f %.6f %.6f %.6f %.8f %.8f %.8f \n",sv[i].yr,sv[i].jd,sv[i].sec,x[i*3],x[i*3+1],x[i*3+2],v[i*3],v[i*3+1],v[i*3+2]); } printf("%d Lines Written for Orbit...\n",count); return(count); }
int TextMatrix::convert(SimpleMatrix* out) const { const int nc = ncol(); const int nr = nrow(); double d = 0; SimpleMatrix& m = *out; m.resize(nr, nc); for (int i = 0; i < nr; ++i) { for (int j = 0; j < nc; ++j) { if (str2double(mat[i][j], &d)) { m[i][j] = d; } else { m[i][j] = NAN; } } } m.setRowName(rowName); m.setColName(colName); return 0; }
/* ****************************************************************** */ int ReadCommandLine(int nargs, char **args) { // Returns 1 if input file is specified and 0 otherwise. int options; // Counters used in getting flags int ShowHelp=0; // ShowHelp = 1 if help option flag is selected int option_index; char line[MAXLINE]; char param[MAXLINE]; float temp; static struct option long_options [] = { {"quiet", no_argument, NULL, 'a'}, {"ordered", no_argument, NULL, 'b'}, {"out", required_argument, NULL, 'c'}, {"pairs", no_argument, NULL, 'd'}, {"T", required_argument, NULL, 'e'}, {"dangles", required_argument, NULL, 'f'}, {"material", required_argument, NULL, 'g'}, {"help", no_argument, NULL, 'h'}, {"timeonly", no_argument, NULL, 'i'}, {"listonly", no_argument, NULL, 'w'}, {"debug", no_argument, NULL, 'v'}, {"echo", no_argument, NULL, 'j'}, {"mfe", no_argument, NULL, 'k'}, {"cutoff", required_argument, NULL, 'l'}, {"progress", no_argument, NULL, 'm'}, {"degenerate",no_argument, NULL, 'n'}, {"sodium", required_argument, NULL, 'o'}, {"magnesium", required_argument, NULL, 'p'}, {"longhelixsalt", no_argument, NULL, 'q'}, {"validate",no_argument,NULL,'r'}, {"defect",no_argument,NULL,'s'}, {0, 0, 0, 0} }; NUPACK_VALIDATE=0; // Get the option flags while (1) { /* getopt_long stores the option index here. */ option_index = 0; options = getopt_long_only (nargs, args, "abcde:f:g:h:ijkl:mno:p:qrs", long_options, &option_index); // Detect the end of the options. if (options == -1) break; switch (options) { case 'a': globalArgs.quiet = 1; break; case 'b': globalArgs.permsOn = 1; break; case 'c': strcpy( line, optarg); if( sscanf(line, "%d", &(globalArgs.out)) != 1) { printf("Invalid out value\n"); exit(1); } break; case 'd': globalArgs.dopairs = 1; break; case 'e': strcpy( line, optarg); if( sscanf(line, "%f", &(temp)) != 1) { printf("Invalid T value\n"); exit(1); } globalArgs.T = (long double) temp; break; case 'f': strcpy( line, optarg); if( sscanf(line, "%s", param) != 1) { printf("Invalid parameters value\n"); exit(1); } if (isdigit(param[0])) { globalArgs.dangles = atoi(param); } else { if (!strcmp(param,"none")) { globalArgs.dangles = 0; } else if (!strcmp(param,"some")) { globalArgs.dangles = 1; } else if (!strcmp(param,"all")) { globalArgs.dangles = 2; } else { printf("Invalid dangles value\n"); exit(1); } } break; case 'g': strcpy( line, optarg); if( sscanf(line, "%s", param) != 1) { printf("Invalid parameters value\n"); exit(1); } else if( !strcmp(param, "dna") || !strcmp(param, "dna1998")) { globalArgs.parameters = DNA; } else if( !strcmp(param, "rna") || !strcmp(param, "rna1995") ) { globalArgs.parameters = RNA; } else if( !strcmp(param, "rna37") || !strcmp(param, "rna1999") ) { if(strcmp(PARAM_FILE,"rna37") == 0) { printf("Parameter specification using rna37 has been deprecated. Please use rna1999 instead\n"); } globalArgs.parameters = RNA37; } else { globalArgs.parameters = USE_SPECIFIED_PARAMETERS_FILE; strcpy( PARAM_FILE, param); } break; case 'h': ShowHelp = 1; break; case 'i': globalArgs.timeonly = 1; break; case 'w': globalArgs.listonly = 1; break; case 'v': globalArgs.debug = 1; break; case 'j': globalArgs.echo = 1; break; case 'k': globalArgs.mfe = 1; break; case 'l': strcpy( line, optarg); if( sscanf(line, "%f", &(temp)) != 1) { printf("Invalid cutoff value\n"); exit(1); } globalArgs.cutoff = (long double) temp; break; case 'm': globalArgs.progress = 1; break; case 'n': globalArgs.onlyOneMFE = 0; break; case 'o': strcpy( line, optarg); globalArgs.sodiumconc = str2double(line); break; case 'p': strcpy( line, optarg); globalArgs.magnesiumconc = str2double(line); break; case 'q': globalArgs.uselongsalt = 1; break; case '?': // getopt_long already printed an error message. break; case 'r': NUPACK_VALIDATE=1; globalArgs.permsOn = 1; globalArgs.cutoff = 0.0; break; case 's': globalArgs.dodefect = 1; break; default: abort (); } } if (ShowHelp) { DisplayHelpComplexes(); exit(1); } // Check salt inputs to make sure we're ok if ((globalArgs.sodiumconc != 1.0 || globalArgs.magnesiumconc != 0.0) && globalArgs.parameters != DNA) { printf("WARNING: No salt corrections availabe for RNA. Using 1 M Na and 0 M Mg.\n"); globalArgs.sodiumconc = 1.0; globalArgs.magnesiumconc = 0.0; } if (globalArgs.sodiumconc <= 0.0) { printf("ERROR: In valid sodium concentration. Must have [Na+] > 0.\n"); exit(1); } if (globalArgs.magnesiumconc < 0.0) { printf("ERROR: In valid magnesium concentration. Must have [Mg2+] >= 0.\n"); exit(1); } if (globalArgs.sodiumconc < 0.05 || globalArgs.sodiumconc > 1.1) { printf("WARNING: Salt correction only verified for 0.05 M < [Na+] < 1.1 M.\n"); printf(" [Na+] = %g M may give erroneous results.\n",(float) globalArgs.sodiumconc); } if (globalArgs.magnesiumconc > 0.2) { printf("WARNING: Salt correction only verified for [Mg2+] <= 0.2 M.\n"); printf(" [Mg2+] = %g M may give erroneous results.\n",(float) globalArgs.magnesiumconc); } // The range of validity of the magnesium correction is unknown if (globalArgs.uselongsalt && globalArgs.magnesiumconc > 0.0) { printf("WARNING: No magnesium correction parameters are available for the long\n"); printf(" helix mode of salt correction. Using [Mg2+] = 0.\n"); globalArgs.magnesiumconc = 0.0; } // Get the the input file if (optind == nargs) { // There's no input from the user return 0; } else { strcpy(globalArgs.inputFilePrefix,args[optind]); } return 1; }
void OFDMletters2bits(const emlrtStack *sp, const char_T str[80], real_T f[560]) { int32_T bits_size_idx_1; char_T bits_data[1280]; int32_T i2; int32_T firstcol; int32_T j; boolean_T exitg1; boolean_T p; int32_T i; boolean_T exitg2; char_T b_bits_data[1280]; const mxArray *y; const mxArray *m4; emlrtStack st; st.prev = sp; st.tls = sp->tls; /* Encode a string of ASCII text into bits(1,0) */ st.site = &hf_emlrtRSI; bits_size_idx_1 = 16; for (i2 = 0; i2 < 1280; i2++) { bits_data[i2] = '0'; } for (firstcol = 0; firstcol < 80; firstcol++) { for (j = 0; j < 16; j++) { if (((uint8_T)str[firstcol] & 1 << j) != 0) { bits_data[firstcol + 80 * (15 - j)] = '1'; } } } firstcol = 16; j = 1; exitg1 = FALSE; while ((exitg1 == FALSE) && (j <= 15)) { p = FALSE; i = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (i <= 79)) { if (bits_data[i + 80 * (j - 1)] != '0') { p = TRUE; exitg2 = TRUE; } else { i++; } } if (p) { firstcol = j; exitg1 = TRUE; } else { j++; } } if (firstcol > 1) { for (j = firstcol; j < 17; j++) { for (i = 0; i < 80; i++) { bits_data[i + 80 * (j - firstcol)] = bits_data[i + 80 * (j - 1)]; } } j = 17 - firstcol; for (i2 = 0; i2 < j; i2++) { memcpy(&b_bits_data[80 * i2], &bits_data[80 * i2], 80U * sizeof(char_T)); } bits_size_idx_1 = 17 - firstcol; j = 17 - firstcol; for (i2 = 0; i2 < j; i2++) { memcpy(&bits_data[80 * i2], &b_bits_data[80 * i2], 80U * sizeof(char_T)); } } for (firstcol = 0; firstcol < 80; firstcol++) { for (i = 0; i < 7; i++) { i2 = 1 + i; emlrtDynamicBoundsCheckFastR2012b(i2, 1, bits_size_idx_1, &c_emlrtBCI, sp); y = NULL; m4 = emlrtCreateString1(bits_data[firstcol + 80 * i]); emlrtAssign(&y, m4); st.site = &er_emlrtRSI; f[firstcol + 80 * i] = emlrt_marshallIn(&st, str2double(&st, y, &b_emlrtMCI), "str2double"); emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } }
void b_OFDMletters2bits(const emlrtStack *sp, real_T f[560]) { int32_T bits_size_idx_1; char_T bits_data[1280]; int32_T i14; int32_T firstcol; static const char_T cv93[80] = { 'L', 'i', 'v', 'e', ' ', 'l', 'o', 'n', 'g', ' ', 'a', 'n', 'd', ' ', 'p', 'r', 'o', 's', 'p', 'e', 'r', ',', ' ', 'f', 'r', 'o', 'm', ' ', 't', 'h', 'e', ' ', 'C', 'o', 'm', 'm', 'u', 'n', 'i', 'c', 'a', 't', 'i', 'o', 'n', 's', ' ', 'S', 'y', 's', 't', 'e', 'm', ' ', 'T', 'o', 'o', 'l', 'b', 'o', 'x', ' ', 'T', 'e', 'a', 'm', ' ', 'a', 't', ' ', 'M', 'a', 't', 'h', 'W', 'o', 'r', 'k', 's', '!' }; uint16_T dk; int32_T j; boolean_T exitg1; boolean_T p; int32_T i; boolean_T exitg2; char_T b_bits_data[1280]; const mxArray *y; const mxArray *m12; emlrtStack st; st.prev = sp; st.tls = sp->tls; /* Encode a string of ASCII text into bits(1,0) */ st.site = &hf_emlrtRSI; bits_size_idx_1 = 16; for (i14 = 0; i14 < 1280; i14++) { bits_data[i14] = '0'; } for (firstcol = 0; firstcol < 80; firstcol++) { dk = (uint16_T)cv93[firstcol]; for (j = 0; j < 16; j++) { if ((dk & 1 << j) != 0) { bits_data[firstcol + 80 * (15 - j)] = '1'; } } } firstcol = 16; j = 1; exitg1 = FALSE; while ((exitg1 == FALSE) && (j <= 15)) { p = FALSE; i = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (i <= 79)) { if (bits_data[i + 80 * (j - 1)] != '0') { p = TRUE; exitg2 = TRUE; } else { i++; } } if (p) { firstcol = j; exitg1 = TRUE; } else { j++; } } if (firstcol > 1) { for (j = firstcol; j < 17; j++) { for (i = 0; i < 80; i++) { bits_data[i + 80 * (j - firstcol)] = bits_data[i + 80 * (j - 1)]; } } j = 17 - firstcol; for (i14 = 0; i14 < j; i14++) { memcpy(&b_bits_data[80 * i14], &bits_data[80 * i14], 80U * sizeof(char_T)); } bits_size_idx_1 = 17 - firstcol; j = 17 - firstcol; for (i14 = 0; i14 < j; i14++) { memcpy(&bits_data[80 * i14], &b_bits_data[80 * i14], 80U * sizeof(char_T)); } } for (firstcol = 0; firstcol < 80; firstcol++) { for (i = 0; i < 7; i++) { i14 = 1 + i; emlrtDynamicBoundsCheckFastR2012b(i14, 1, bits_size_idx_1, &c_emlrtBCI, sp); y = NULL; m12 = emlrtCreateString1(bits_data[firstcol + 80 * i]); emlrtAssign(&y, m12); st.site = &er_emlrtRSI; f[firstcol + 80 * i] = emlrt_marshallIn(&st, str2double(&st, y, &b_emlrtMCI), "str2double"); emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp); } }
static void parse_commandline(int argc, char* argv[], specs * s) { int i; if (argc < 2) usage(); i = 1; while (i < argc) { if (argv[i][0] != '-') usage(); switch (argv[i][1]) { case 'c': i++; s->square = 0; s->invariant = 1; break; case 'i': i++; if (i >= argc) quit("no file name found after -i\n"); s->fin = argv[i]; i++; break; case 'l': i++; s->linear = 1; break; case 'n': i++; s->fout = NULL; s->generate_points = 1; if (i >= argc) quit("no grid dimensions found after -n\n"); if (sscanf(argv[i], "%dx%d", &s->nx, &s->ny) != 2) quit("could not read grid dimensions after \"-n\"\n"); #if defined(NN_SERIAL) if (s->nx <= 0 || s->ny <= 0) #else if (s->nx <= 0 || s->nx > NMAX || s->ny <= 0 || s->ny > NMAX) #endif quit("invalid size for output grid\n"); i++; break; case 'o': i++; if (i >= argc) quit("no file name found after -o\n"); s->fout = argv[i]; i++; break; case 's': i++; s->square = 1; s->invariant = 0; break; case 'x': if (argv[i][2] == 0) { i++; if (i >= argc) quit("no xmin value found after -x\n"); s->xmin = str2double(argv[i], "-x"); i++; if (i >= argc) quit("no xmax value found after -x\n"); s->xmax = str2double(argv[i], "-x"); i++; } else if (strcmp(argv[i], "-xmin") == 0) { i++; if (i >= argc) quit("no value found after -xmin\n"); s->xmin = str2double(argv[i], "-xmin"); i++; } else if (strcmp(argv[i], "-xmax") == 0) { i++; if (i >= argc) quit("no value found after -xmax\n"); s->xmax = str2double(argv[i], "-xmax"); i++; } else usage(); break; case 'y': if (argv[i][2] == 0) { i++; if (i >= argc) quit("no ymin value found after -y\n"); s->ymin = str2double(argv[i], "-y"); i++; if (i >= argc) quit("no ymax value found after -y\n"); s->ymax = str2double(argv[i], "-y"); i++; } else if (strcmp(argv[i], "-ymin") == 0) { i++; if (i >= argc) quit("no value found after -ymin\n"); s->ymin = str2double(argv[i], "-ymin"); i++; } else if (strcmp(argv[i], "-ymax") == 0) { i++; if (i >= argc) quit("no value found after -ymax\n"); s->ymax = str2double(argv[i], "-ymax"); i++; } else usage(); break; case 'v': i++; nn_verbose = 1; break; case 'z': i++; if (i >= argc) quit("no zoom value found after -z\n"); s->zoom = str2double(argv[i], "-z"); i++; break; case 'D': i++; s->thin = 1; if (argc > i && argv[i][0] != '-') { if (sscanf(argv[i], "%dx%d", &s->nxd, &s->nyd) != 2) quit("could not read grid dimensions after \"-D\"\n"); if (s->nxd <= 0 || s->nyd <= 0) quit("invalid value for nx = %d or ny = %d after -D option\n", s->nxd, s->nyd); #if !defined(NN_SERIAL) if (s->nxd > NMAX || s->nyd > NMAX) quit("too big value after -D option (expected < %d)\n", NMAX); #endif i++; } break; case 'L': i++; s->thin = 2; if (i >= argc) quit("no value found after -L\n"); s->rmax = str2double(argv[i], "-L"); i++; break; case 'N': i++; s->nointerp = 1; break; case 'P': { char delim[] = "="; char prmstr[STRBUFSIZE] = ""; char* token; i++; if (i >= argc) quit("no input found after -P\n"); if (strlen(argv[i]) >= STRBUFSIZE) quit("could not interpret \"%s\" after -P option\n", argv[i]); strcpy(prmstr, argv[i]); token = strtok(prmstr, delim); if (token == NULL) quit("could not interpret \"%s\" after -P option\n", argv[i]); if (strcmp(token, "alg") == 0) { token = strtok(NULL, delim); if (token == NULL) quit("could not interpret \"%s\" after -P option\n", argv[i]); if (strcmp(token, "nn") == 0) { nn_rule = SIBSON; s->linear = 0; } else if (strcmp(token, "ns") == 0) { nn_rule = NON_SIBSONIAN; s->linear = 0; } else if (strcmp(token, "l") == 0) { s->linear = 1; } else usage(); } i++; break; } case 'W': i++; if (i >= argc) quit("no minimal allowed weight found after -W\n"); s->wmin = str2double(argv[i], "-W"); i++; break; case 'T': i++; if (i >= argc) quit("no vertex id found after -T\n"); nn_test_vertice = atoi(argv[i]); nn_verbose = 1; i++; break; case 'V': i++; nn_verbose = 2; break; #if defined(NN_SERIAL) case '%': i++; if (i < argc && argv[i][0] != '-') { s->npoints = atoi(argv[i]); i++; } else s->npoints = 1; break; #endif default: usage(); break; } } if (nn_verbose && argc == 2) version(); if (s->thin) { if (s->nxd == -1) s->nxd = s->nx; if (s->nyd == -1) s->nyd = s->ny; if (s->nxd <= 0 || s->nyd <= 0) quit("invalid grid size for thinning\n"); } #if defined(NN_SERIAL) if (s->npoints == 1) { if (s->nx <= 0) s->npoints = 0; else s->npoints = s->nx * s->ny; } #endif }
/** * Extract covaraite from file @param fn. * Only samples included in @param includedSample will be processed * If some samples appear more than once, only the first appearance will be * readed * Only covaraites provided in @param covNameToUse will be included * Missing values will be imputed to the mean columnwise. * Result will be put to @param mat (sample by covariate) and @param * sampleToDrop * @return number of sample loaded (>=0); or a minus number meaning error * @param sampleToDrop: store samples that are not found in covariate. */ int extractCovariate(const std::string& fn, const std::vector<std::string>& sampleToInclude, const std::vector<std::string>& covNameToUse, DataLoader::HandleMissingCov handleMissingCov, SimpleMatrix* mat, std::set<std::string>* sampleToDrop) { std::set<std::string> includeSampleSet; makeSet(sampleToInclude, &includeSampleSet); if (includeSampleSet.size() != sampleToInclude.size()) { logger->warn( "Some samples have appeared more than once, and we record covariate " "for its first appearance"); } std::vector<std::string> noPhenotypeSample; std::map<std::string, int> processed; // record how many times a sample is processed std::set<std::pair<int, int> > missing; // record which number is covaraite is missing. int missingCovariateWarning = 0; // record how many times a missing warning is geneated. bool missingValueInLine; // record whether there is missing value in the // line int missingLines = 0; // record how many lines has missing values std::vector<int> columnToExtract; std::vector<std::string> extractColumnName; std::vector<std::string> fd; LineReader lr(fn); int lineNo = 0; int fieldLen = 0; while (lr.readLineBySep(&fd, "\t ")) { ++lineNo; if (lineNo == 1) { // header line fieldLen = fd.size(); if (fieldLen < 2) { logger->error( "Insufficient column number (<2) in the first line of covariate " "file!"); return -1; }; if (tolower(fd[0]) != "fid" || tolower(fd[1]) != "iid") { logger->error("Covariate file header should begin with \"FID IID\"!"); return -1; } std::map<std::string, int> headerMap; makeMap(fd, &headerMap); if (fd.size() != headerMap.size()) { logger->error("Covariate file have duplicated header!"); return -1; } // specify which covariates to extract if (covNameToUse.size()) { for (size_t i = 0; i < covNameToUse.size(); ++i) { if (headerMap.count(covNameToUse[i]) == 0) { logger->error( "The covariate [ %s ] you specified cannot be found from " "covariate file!", covNameToUse[i].c_str()); continue; } columnToExtract.push_back(headerMap[covNameToUse[i]]); extractColumnName.push_back(covNameToUse[i]); } } else { for (size_t i = 2; i < fd.size(); ++i) { columnToExtract.push_back(headerMap[fd[i]]); extractColumnName.push_back(fd[i]); } } } else { // body lines if (fd.empty() || (fd[0].empty() && fd.size() == 1)) { // skip empty lines continue; } if ((int)fd.size() != fieldLen) { logger->error( "Inconsistent column number in covariate file line [ %d ] - skip " "this file!", lineNo); return -1; } if (includeSampleSet.find(fd[1]) == includeSampleSet.end()) { // does not have phenotype noPhenotypeSample.push_back(fd[1]); continue; }; processed[fd[1]]++; if (processed[fd[1]] > 1) { logger->info("Duplicate sample [ %s ] in covariate file, skipping", fd[1].c_str()); continue; }; int idx = (*mat).nrow(); (*mat).resize(idx + 1, columnToExtract.size()); (*mat).setRowName(idx, fd[1]); missingValueInLine = false; for (int i = 0; i < (int)columnToExtract.size(); ++i) { double d; if (str2double(fd[columnToExtract[i]], &d)) { (*mat)[idx][i] = d; } else { // found missing missingValueInLine = true; ++missingCovariateWarning; if (missingCovariateWarning <= 10) { if (handleMissingCov == DataLoader::COVARIATE_IMPUTE) { logger->warn( "Covariate file line [ %d ] has non-numerical value [ %s " "], " "we will impute to its mean", lineNo, fd[columnToExtract[i]].c_str()); } else if (handleMissingCov == DataLoader::COVARIATE_DROP) { logger->warn( "Covariate file line [ %d ] has non-numerical value [ %s " "], " "we will skip this sample", lineNo, fd[columnToExtract[i]].c_str()); } } (*mat)[idx][i] = 0.0; // will later be updated missing.insert(std::make_pair(idx, i)); }; } if (!missing.empty() && handleMissingCov == DataLoader::COVARIATE_DROP) { // drop row and row name (*mat).deleteRow((*mat).nrow() - 1); missing.clear(); } missingLines += missingValueInLine ? 1 : 0; } } if (missingCovariateWarning > 10) { if (handleMissingCov == DataLoader::COVARIATE_IMPUTE) { logger->warn( "Total [ %d ] lines in covariate file contain non-numerical " "values, " "we will impute these to their mean", missingLines); } else if (handleMissingCov == DataLoader::COVARIATE_DROP) { logger->warn( "Total [ %d ] lines in covariate file contain non-numerical " "values, " "we will skip these lines", missingLines); } } // output samples in covaraite but without phenotype for (size_t i = 0; i < noPhenotypeSample.size(); ++i) { if (i == 0) logger->warn( "Total [ %zu ] samples are skipped from covariate file due to " "missing phenotype", noPhenotypeSample.size()); if (i > 10) { logger->warn( "Skip outputting additional [ %d ] samples from covariate file " "with " "missing phenotypes", ((int)noPhenotypeSample.size() - 10)); break; } logger->warn( "Skip sample [ %s ] from covariate file due to missing phenotype", (noPhenotypeSample)[i].c_str()); } // set up labels for (size_t i = 0; i < extractColumnName.size(); ++i) { mat->setColName(i, extractColumnName[i]); } for (size_t i = 0; i < sampleToInclude.size(); i++) { if (processed.find(sampleToInclude[i]) == processed.end()) { logger->warn("Covariate file does not contain sample [ %s ]", sampleToInclude[i].c_str()); sampleToDrop->insert(sampleToInclude[i]); }; } if (handleMissingCov == DataLoader::COVARIATE_DROP) { assert(missing.empty()); return (*mat).nrow(); } // impute missing covariates to mean by column for (int col = 0; col < mat->ncol(); ++col) { double sum = 0; int nonZero = 0; for (int row = 0; row < (*mat).nrow(); ++row) { if (missing.count(std::make_pair(row, col))) continue; // missing sum += (*mat)[row][col]; ++nonZero; } if (nonZero == 0) { // all column are missing, drop column logger->info( "Covariate [ %s ] is missing for all samples. Exclude please " "before " "continue!", mat->getColName()[col].c_str()); return -1; } // some elements are missing double mean = sum / nonZero; for (int row = 0; row < (*mat).nrow(); ++row) { if (missing.count(std::make_pair(row, col))) { (*mat)[row][col] = mean; } } } return (*mat).nrow(); } // end extractCovariate
/** For files of the form ??_yyyymmdd.nc. They are assumed to have "time" * variable. */ void reader_rads_standard(char* fname, int fid, obsmeta* meta, model* m, observations* obs) { double mindepth = MINDEPTH_DEF; char* addname = NULL; int ncid; int dimid_nobs; size_t nobs_local; int varid_lon, varid_lat, varid_pass, varid_sla, varid_time, varid_add; double* lon; double* lat; int* pass; double* sla; double* time; double error_std; double* add = NULL; size_t tunits_len; char* tunits; double tunits_multiple, tunits_offset; char* basename; char instname[3]; int mvid; float** depth; int i, ktop; for (i = 0; i < meta->npars; ++i) { if (strcasecmp(meta->pars[i].name, "MINDEPTH") == 0) { if (!str2double(meta->pars[i].value, &mindepth)) enkf_quit("observation prm file: can not convert MINDEPTH = \"%s\" to double\n", meta->pars[i].value); } else if (strcasecmp(meta->pars[i].name, "ADD") == 0) { addname = meta->pars[i].value; enkf_printf(" ADDING \"%s\"\n", addname); } else enkf_quit("unknown PARAMETER \"%s\"\n", meta->pars[i].name); } enkf_printf(" MINDEPTH = %.0f\n", mindepth); ncw_open(fname, NC_NOWRITE, &ncid); ncw_inq_dimid(ncid, "nobs", &dimid_nobs); ncw_inq_dimlen(ncid, dimid_nobs, &nobs_local); enkf_printf(" nobs = %u\n", (unsigned int) nobs_local); if (nobs_local == 0) { ncw_close(ncid); return; } ncw_inq_varid(ncid, "lon", &varid_lon); lon = malloc(nobs_local * sizeof(double)); ncw_get_var_double(ncid, varid_lon, lon); ncw_inq_varid(ncid, "lat", &varid_lat); lat = malloc(nobs_local * sizeof(double)); ncw_get_var_double(ncid, varid_lat, lat); ncw_inq_varid(ncid, "pass", &varid_pass); pass = malloc(nobs_local * sizeof(int)); ncw_get_var_int(ncid, varid_pass, pass); ncw_inq_varid(ncid, "sla", &varid_sla); sla = malloc(nobs_local * sizeof(double)); ncw_get_var_double(ncid, varid_sla, sla); ncw_get_att_double(ncid, varid_sla, "error_std", &error_std); enkf_printf(" error_std = %3g\n", error_std); if (addname != NULL) { ncw_inq_varid(ncid, addname, &varid_add); add = malloc(nobs_local * sizeof(double)); ncw_get_var_double(ncid, varid_add, add); } ncw_inq_varid(ncid, "time", &varid_time); time = malloc(nobs_local * sizeof(double)); ncw_get_var_double(ncid, varid_time, time); ncw_inq_attlen(ncid, varid_time, "units", &tunits_len); tunits = calloc(tunits_len + 1, 1); ncw_get_att_text(ncid, varid_time, "units", tunits); ncw_close(ncid); tunits_convert(tunits, &tunits_multiple, &tunits_offset); basename = strrchr(fname, '/'); if (basename == NULL) basename = fname; else basename += 1; strncpy(instname, basename, 2); instname[2] = 0; mvid = model_getvarid(m, obs->obstypes[obstype_getid(obs->nobstypes, obs->obstypes, meta->type, 1)].varnames[0], 1); ktop = grid_gettoplayerid(model_getvargrid(m, mvid)); depth = model_getdepth(m, mvid, 1); for (i = 0; i < (int) nobs_local; ++i) { observation* o; obstype* ot; obs_checkalloc(obs); o = &obs->data[obs->nobs]; o->product = st_findindexbystring(obs->products, meta->product); assert(o->product >= 0); o->type = obstype_getid(obs->nobstypes, obs->obstypes, meta->type, 1); ot = &obs->obstypes[o->type]; o->instrument = st_add_ifabscent(obs->instruments, instname, -1); o->id = obs->nobs; o->fid = fid; o->batch = pass[i]; o->value = sla[i]; if (add != NULL) o->value += add[i]; o->std = error_std; o->lon = lon[i]; o->lat = lat[i]; o->depth = 0.0; o->status = model_xy2fij(m, mvid, o->lon, o->lat, &o->fi, &o->fj); if (!obs->allobs && o->status == STATUS_OUTSIDEGRID) continue; o->fk = (double) ktop; o->model_depth = (isnan(o->fi + o->fj)) ? NaN : depth[(int) (o->fj + 0.5)][(int) (o->fi + 0.5)]; o->date = time[i] * tunits_multiple + tunits_offset; if (o->status == STATUS_OK && o->model_depth < mindepth) o->status = STATUS_SHALLOW; if ((o->status == STATUS_OK) && (o->lon <= ot->xmin || o->lon >= ot->xmax || o->lat <= ot->ymin || o->lat >= ot->ymax)) o->status = STATUS_OUTSIDEOBSDOMAIN; o->aux = -1; obs->nobs++; } if (add != NULL) free(add); free(lon); free(lat); free(pass); free(sla); free(tunits); free(time); }
/** * @return number of phenotypes read. -1 if errors * @param phenoCol, which phenotype column to use, similar to plink, it should * be the order of phenotype, e.g. phenoCol = 2, meaning the second phenotype * @param phenoName, which phenotype header to use. */ int loadPedPhenotypeByColumn(const char* fn, std::map<std::string, double>* p, int phenoCol) { if (phenoCol < 0) { logger->error("Phenotype column cannot be negative: [ %d ]", phenoCol); return -1; }; std::map<std::string, double>& pheno = *p; std::map<std::string, int> dup; // duplicates std::string line; std::vector<std::string> fd; LineReader lr(fn); int lineNo = 0; double v; int numMissingPhenotype = 0; while (lr.readLine(&line)) { stringNaturalTokenize(line, "\t ", &fd); ++lineNo; if ((int)fd.size() < 5 + phenoCol) { logger->warn("Skip line %d (short of columns) in phenotype file [ %s ]", lineNo, fn); continue; } if (toupper(fd[0]) == "FID" && toupper(fd[1]) == "IID") { if (lineNo == 1) { // skip header line continue; } else { logger->warn( "SKip line %d because the abnormal family and individual ids [ " "FID " "] and [ IID ]", lineNo); continue; } } std::string& pid = fd[1]; if (pheno.count(pid) == 0) { // check missing if (str2double(fd[5 + phenoCol - 1].c_str(), &v)) { pheno[pid] = v; } else { ++numMissingPhenotype; if (numMissingPhenotype <= 10) { logger->warn( "Skip: Missing or invalid phenotype type, skipping line %d [ " "%s " "] ... ", lineNo, line.c_str()); } continue; } } else { // logger->warn("line %s have duplicated id, skipped..", pid.c_str()); dup[pid]++; continue; } } if (numMissingPhenotype > 10) { logger->warn( "Skip: Additional [ %d ] lines have missing or invalid phenotype " "type", numMissingPhenotype - 10); } for (std::map<std::string, int>::iterator iter = dup.begin(); iter != dup.end(); ++iter) { logger->warn( "Sample [ %s ] removed from phenotype file [ %s ] for its duplicity " "[ " "%d ]", iter->first.c_str(), fn, iter->second + 1); pheno.erase(iter->first); }; return pheno.size(); };
/** * Load kinship file and store the kinship matrix internally */ int KinshipHolder::loadK() { // check kinship file existance if (!fileExists(this->fileName)) { logger->warn("Cannot open kinship file [ %s ]", this->fileName.c_str()); return -1; } const std::vector<std::string>& names = *this->pSample; if (this->fileName == "IDENTITY" || this->fileName == "UNRELATED") { this->matK->mat.resize(names.size(), names.size()); this->matK->mat.setZero(); this->matK->mat.diagonal().setOnes(); this->matK->mat.diagonal() *= 0.5; return 0; } LineReader lr(this->fileName); int lineNo = 0; int fieldLen = 0; std::vector<std::string> fd; std::vector<int> columnToExtract; std::vector<std::string> header; // kinship header line Eigen::MatrixXf& mat = this->matK->mat; std::map<std::string, int> nameMap; makeMap(names, &nameMap); while (lr.readLineBySep(&fd, "\t ")) { ++lineNo; if (lineNo == 1) { // check header header = fd; fieldLen = fd.size(); if (fieldLen < 2) { logger->error( "Insufficient column number (<2) in the first line of kinsihp " "file!"); return -1; }; if (tolower(fd[0]) != "fid" || tolower(fd[1]) != "iid") { logger->error("Kinship file header should begin with \"FID IID\"!"); return -1; } std::map<std::string, int> headerMap; makeMap(fd, &headerMap); if (fd.size() != headerMap.size()) { logger->error("Kinship file have duplicated header!"); return -1; } for (size_t i = 0; i < names.size(); ++i) { if (headerMap.count(names[i]) == 0) { logger->error("Cannot find sample [ %s ] from the kinship file!", names[i].c_str()); return -1; } columnToExtract.push_back(headerMap[names[i]]); } mat.resize(columnToExtract.size(), columnToExtract.size()); continue; } // body lines if ((int)fd.size() != fieldLen) { logger->error( "Inconsistent column number [ %zu ] (used to be [ %d ]) in kinship " "file line [ %d ] - skip this file!", fd.size(), fieldLen, lineNo); // todo: this error may be false alarm - as the last line may be empty continue; // exit(1); } if (fd[1] != header[lineNo]) { // PID in line i (1-based) should matched // the (i+1) (1-based) column in the header logger->error( "Inconsistent IID names in kinship file line [ %d ], file corrupted!", lineNo); return -1; } int row; if (nameMap.find(fd[1]) == nameMap.end()) { continue; } row = nameMap[fd[1]]; for (size_t i = 0; i < columnToExtract.size(); ++i) { double d; if (str2double(fd[columnToExtract[i]], &d)) { mat(row, i) = d; } else { // unable to read, then set it to zero mat(row, i) = 0.0; } } } #ifdef DEBUG std::string tmp = fn; tmp += ".tmp"; std::ofstream ofs(tmp.c_str(), std::ofstream::out); ofs << mat; ofs.close(); #endif // fprintf(stderr, "Kinship matrix [ %d x %d ] loaded", (int)mat.rows(), // (int)mat.cols()); this->loaded = true; return 0; }
model* model_create(enkfprm* prm) { model* m = calloc(1, sizeof(model)); char* modelprm = prm->modelprm; char* gridprm = prm->gridprm; model_setgrids(m, gridprm); /* * read model parameter file */ { FILE* f = NULL; char buf[MAXSTRLEN]; int line; variable* now = NULL; /* * get model tag, type and variables */ f = enkf_fopen(modelprm, "r"); line = 0; while (fgets(buf, MAXSTRLEN, f) != NULL) { char seps[] = " =\t\n"; char* token = NULL; line++; if (buf[0] == '#') continue; if ((token = strtok(buf, seps)) == NULL) continue; if (strcasecmp(token, "NAME") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: NAME not specified", modelprm, line); else if (m->name != NULL) enkf_quit("%s, l.%d: NAME specified twice", modelprm, line); else m->name = strdup(token); } else if (strncasecmp(token, "VAR", 3) == 0) { int i; if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: VAR not specified", modelprm, line); for (i = 0; i < m->nvar; ++i) if (strcasecmp(m->vars[i].name, token) == 0) enkf_quit("%s, l.%d: VAR \"%s\" already specified", modelprm, line, token); if (m->nvar % NVAR_INC == 0) m->vars = realloc(m->vars, (m->nvar + NVAR_INC) * sizeof(variable)); now = &m->vars[m->nvar]; variable_new(now, m->nvar, token); m->nvar++; } else if (strcasecmp(token, "GRID") == 0) { int i; if (now == NULL) enkf_quit("%s, l.%d: VAR not specified", modelprm, line); if (now->gridid >= 0) enkf_quit("%s, l.%d: GRID already specified for \"%s\"", modelprm, line, now->name); if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: GRID not specified", modelprm, line); for (i = 0; i < m->ngrid; ++i) if (strcasecmp(token, grid_getname(m->grids[i])) == 0) { now->gridid = i; break; } if (i == m->ngrid) enkf_quit("%s, l.%d: grid \"%s\" not specified", modelprm, line, token); } else if (strcasecmp(token, "INFLATION") == 0) { if (now == NULL) enkf_quit("%s, l.%d: VAR not specified", modelprm, line); if (!isnan(now->inflation)) enkf_quit("%s, l.%d: INFLATION already specified for \"%s\"", modelprm, line, now->name); if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: INFLATION not specified", modelprm, line); if (!str2double(token, &now->inflation)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", modelprm, line, token); if ((token = strtok(NULL, seps)) != NULL) { if (!str2double(token, &now->inf_ratio)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", modelprm, line, token); } } else enkf_quit("%s, l.%d: unknown token \"%s\"", modelprm, line, token); } /* while reading modelprm */ fclose(f); assert(m->name != NULL); assert(m->nvar > 0); { int i; for (i = 0; i < m->nvar; ++i) if (m->vars[i].gridid == -1) { if (m->ngrid == 1) m->vars[i].gridid = 0; else enkf_quit("%s: grid not specified for variable \"%s\"\n", modelprm, m->vars[i].name); } } } /* * set inflations */ { int i; for (i = 0; i < m->nvar; ++i) if (isnan(m->vars[i].inflation)) { m->vars[i].inflation = prm->inflation_base; m->vars[i].inf_ratio = prm->inf_ratio; } prm->inflation_base = NaN; prm->inf_ratio = NaN; } model_print(m, " "); assert(m->ngrid > 0); return m; }
void ParameterParser::Read(int argc, char** argv) { std::string flag; for (int i = 1; i < argc; i++) { // removing leading - or -- for flags flag = argv[i]; // flag = '--' meaning the end of all parameter if (flag == "--") { ++i; while (i < argc) { FLAG_REMAIN_ARG.push_back(argv[i++]); } return; } // flag = '-' meaning standard input, we will put it in the remaingArg if (flag == "-") { FLAG_REMAIN_ARG.push_back(argv[i]); continue; } unsigned int choppedLeadingDash = 0; // user may input ---flag, ----flag, ..., and we will chop all leading - // user may also input ---, ----, but I don't understand what that means, // so report error while (flag.size() > 0) { if (flag[0] == '-') { choppedLeadingDash++; flag = flag.substr(1); } else { break; } } if (flag.empty()) { fprintf(stderr, "ERROR: we don't understand the argument \"%s\"\n", argv[i]); return; } if (choppedLeadingDash > 2) { fprintf(stderr, "WARNING: you typed too many dash in \"%s\"?\n", argv[i]); } else if (choppedLeadingDash == 1 && flag.size() > 1) { fprintf(stderr, "WARNING: long parameter should have two lead dashes: \"%s\"?\n", argv[i]); } else if (choppedLeadingDash > 1 && flag.size() == 1) { fprintf(stderr, "WARNING: long parameter should have two lead dashes: \"%s\"?\n", argv[i]); } // check if variable flag is a predefined flag or not std::vector<std::string>::iterator it; for (it = flagVec.begin(); it != flagVec.end(); it++) { if (*it == flag) { break; } } // variable flag will be added to remainingArg if (it == flagVec.end()) { FLAG_REMAIN_ARG.push_back(argv[i]); continue; } // NOTE: // we could check if user misuse -- and - // but i did not see much use here. // parse data unsigned int idx = it - flagVec.begin(); void* data = flagInfoMap[idx].data; if (flagInfoMap[idx].isParsed) { fprintf(stderr, "WARNING: flag \"%s\" provided more than once, the previous " "value will be overwritten\n", argv[i]); } flagInfoMap[idx].isParsed = true; switch (flagInfoMap[idx].pt) { case BOOL_TYPE: *(bool*)data = true; break; case INT_TYPE: if (i + 1 == argc) { fprintf(stderr, "ERROR: missing parameter value after [ %s ]!\n", argv[i]); exit(1); } if (!str2int(argv[i + 1], (int*)data)) { fprintf(stderr, "WARNING: arg \"%s %s\" does not give valid integer\n", argv[i], argv[i + 1]); } ++i; break; case DOUBLE_TYPE: if (i + 1 == argc) { fprintf(stderr, "ERROR: missing parameter value after [ %s ]!\n", argv[i]); exit(1); } if (!str2double(argv[i + 1], (double*)data)) { fprintf(stderr, "WARNING: arg \"%s %s\" does not give valid double\n", argv[i], argv[i + 1]); } ++i; break; case STRING_TYPE: if (i + 1 == argc) { fprintf(stderr, "ERROR: missing parameter value after [ %s ]!\n", argv[i]); exit(1); } *(std::string*)data = argv[++i]; break; default: fprintf(stderr, "ERROR: Unrecognized parameter type for flag %s\n", argv[i]); return; } } }
/** * Invoked to handle ASCII commands. This is the default * mode for statsite, to be backwards compatible with statsd * @arg handle The connection related information * @return 0 on success. */ static int handle_ascii_client_connect(statsite_conn_handler *handle) { // Look for the next command line char *buf, *key, *val_str, *type_str, *sample_str, *endptr; metric_type type; int buf_len, should_free, status, i, after_len; double val, sample_rate; while (1) { status = extract_to_terminator(handle->conn, '\n', &buf, &buf_len, &should_free); if (status == -1) return 0; // Return if no command is available // Check for a valid metric // Scan for the colon status = buffer_after_terminator(buf, buf_len, ':', &val_str, &after_len); if (likely(!status)) status |= buffer_after_terminator(val_str, after_len, '|', &type_str, &after_len); if (unlikely(status)) { syslog(LOG_WARNING, "Failed parse metric! Input: %s", buf); goto ERR_RET; } // Convert the type switch (*type_str) { case 'c': type = COUNTER; break; case 'm': type = TIMER; break; case 'k': type = KEY_VAL; break; case 'g': type = GAUGE; // Check if this is a delta update switch (*val_str) { case '+': // Advance past the + to avoid breaking str2double val_str++; case '-': type = GAUGE_DELTA; } break; case 's': type = SET; break; default: type = UNKNOWN; syslog(LOG_WARNING, "Received unknown metric type! Input: %c", *type_str); goto ERR_RET; } // Increment the number of inputs received if (GLOBAL_CONFIG->input_counter) metrics_add_sample(GLOBAL_METRICS, COUNTER, GLOBAL_CONFIG->input_counter, 1); // Fast track the set-updates if (type == SET) { metrics_set_update(GLOBAL_METRICS, buf, val_str); goto END_LOOP; } // Convert the value to a double val = str2double(val_str, &endptr); if (unlikely(endptr == val_str)) { syslog(LOG_WARNING, "Failed value conversion! Input: %s", val_str); goto ERR_RET; } // Handle counter sampling if applicable if (type == COUNTER && !buffer_after_terminator(type_str, after_len, '@', &sample_str, &after_len)) { sample_rate = str2double(sample_str, &endptr); if (unlikely(endptr == sample_str)) { syslog(LOG_WARNING, "Failed sample rate conversion! Input: %s", sample_str); goto ERR_RET; } if (sample_rate > 0 && sample_rate <= 1) { // Magnify the value val = val * (1.0 / sample_rate); } } // Store the sample metrics_add_sample(GLOBAL_METRICS, type, buf, val); END_LOOP: // Make sure to free the command buffer if we need to if (should_free) free(buf); } return 0; ERR_RET: if (should_free) free(buf); return -1; }
static spt str_to_spt(const struct formatter_field *field, const char *str, bool *success) { spt value; bool conv_ok = false; const unsigned int field_width = get_width(field); const uint64_t mask = (field_width < 64) ? (1llu << field_width) - 1 : 0xffffffffffffffffllu; *success = false; switch (field->format) { case FORMATTER_FMT_HEX: case FORMATTER_FMT_UNSIGNED_DEC: { uint64_t tmp = str2uint64(str, 0, UINT64_MAX, &conv_ok); if (!conv_ok) { goto inval; } tmp = (uint64_t) (((float) tmp - field->offset) / field->scaling); value = spt_from_uint64(tmp); break; } case FORMATTER_FMT_TWOS_COMPLEMENT: { int64_t tmp = str2int64(str, INT64_MIN, INT64_MAX, &conv_ok); if (!conv_ok) { goto inval; } tmp = (int64_t) (((float) tmp - field->offset) / field->scaling); value = spt_from_int64(tmp); /* Mask off sign-extended bits to field with */ value &= mask; break; } case FORMATTER_FMT_SIGN_MAGNITUDE: { int64_t tmp = str2int64(str, INT64_MIN, INT64_MAX, &conv_ok); bool negative = (tmp < 0); if (!conv_ok) { goto inval; } tmp = (int64_t) (((float) tmp - field->offset) / field->scaling); /* Field width includes sign bit (assumed to be MSB) */ tmp &= (1 << (field_width - 1)) - 1; if (negative) { tmp |= (1 << (field_width - 1)); } value = spt_from_uint64((uint64_t) tmp); break; } case FORMATTER_FMT_FLOAT: { float tmp = (float) str2double(str, -DBL_MAX, DBL_MAX, &conv_ok); if (!conv_ok) { goto inval; } value = spt_from_float((float) tmp, field->scaling, field->offset); /* Mask off sign-extended bits to field with */ value &= mask; break; } case FORMATTER_FMT_ENUM: { size_t i; bool have_enum = false; for (i = 0; i < field->enum_count && !have_enum; i++) { if (!strcasecmp(str, field->enums[i].str)) { value = field->enums[i].value; have_enum = true; } } if (!have_enum) { uint64_t tmp = str2uint64(str, 0, UINT64_MAX, &conv_ok); if (!conv_ok) { goto inval; } value = spt_from_uint64(tmp); } break; } default: log_critical("Bug: Invalid field format: %d\n", field->format); return spt_from_uint64(0); } if ((spt_to_uint64(value) & mask) != spt_to_uint64(value)) { log_error("Value is too large for field \"%s\": %s\n", field->name, str); return spt_from_uint64(0); } *success = true; return value; inval: log_error("Invalid value for field \"%s\": %s\n", field->name, str); return spt_from_uint64(0); }
int KinshipHolder::loadDecomposed() { LineReader lr(this->eigenFileName); int lineNo = 0; int fieldLen = 0; std::vector<std::string> fd; std::vector<int> columnToExtract; std::vector<std::string> header; // header line of the kinship eigen file Eigen::MatrixXf& matK = this->matK->mat; Eigen::MatrixXf& matS = this->matS->mat; Eigen::MatrixXf& matU = this->matU->mat; const std::vector<std::string>& names = *this->pSample; const int NumSample = (int)names.size(); std::map<std::string, int> nameMap; makeMap(names, &nameMap); std::map<std::string, int> headerMap; while (lr.readLineBySep(&fd, "\t ")) { ++lineNo; if (lineNo == 1) { // check header header = fd; fieldLen = fd.size(); if (fieldLen < 3) { // at least three columns: IID, Lambda, U1 logger->error( "Insufficient column number (<3) in the first line of kinsihp " "file!"); return -1; }; for (size_t i = 0; i != fd.size(); ++i) { fd[i] = tolower(fd[i]); } makeMap(fd, &headerMap); if (fd.size() != headerMap.size()) { logger->error("Kinship file have duplicated headers!"); return -1; } // check IID, Lambda, U1, U2, ... U(N) where (N) is the sample size if (headerMap.count("iid") == 0) { logger->error("Missing 'IID' column!"); return -1; } columnToExtract.push_back(headerMap["iid"]); if (headerMap.count("lambda") == 0) { logger->error("Missing 'Lambda' column!"); return -1; } columnToExtract.push_back(headerMap["lambda"]); std::string s; for (int i = 0; i < NumSample; ++i) { s = "u"; s += toString(i + 1); if (headerMap.count(s) == 0) { logger->error("Missing '%s' column!", s.c_str()); return -1; } columnToExtract.push_back(headerMap[s]); } s = "u"; s += toString(NumSample + 1); if (headerMap.count(s) != 0) { logger->error("Unexpected column '%s'!", s.c_str()); return -1; } matS.resize(NumSample, 1); matU.resize(NumSample, NumSample); continue; } // body lines if ((int)fd.size() != fieldLen) { logger->error( "Inconsistent column number [ %zu ] (used to be [ %d ])in kinship " "file line [ %d ] - skip this file!", fd.size(), fieldLen, lineNo); return -1; } const int iidColumn = columnToExtract[0]; const std::string& iid = fd[iidColumn]; if (nameMap.count(iid) == 0) { logger->error("Unexpected sample [ %s ]!", iid.c_str()); return -1; } const int row = nameMap[iid]; const int lambdaColumn = columnToExtract[1]; double temp = 0.0; if (!str2double(fd[lambdaColumn], &temp)) { logger->warn("Invalid numeric value [ %s ] treated as zero!", fd[lambdaColumn].c_str()); } matS(lineNo - 2, 0) = temp; for (int i = 0; i < NumSample; ++i) { int uColumn = columnToExtract[i + 2]; if (!str2double(fd[uColumn], &temp)) { logger->warn("Invalid numeric value [ %s ] treated as zero!", fd[lambdaColumn].c_str()); } matU(row, i) = temp; } } // verify eigen decomposition results make senses // check largest eigen vector and eigen value Eigen::MatrixXf v1 = matK * matU.col(0); Eigen::MatrixXf v2 = matS(0, 0) * matU.col(0); if (matS(0, 0) > 0.5 && v1.col(0).norm() > .5 && v2.col(0).norm() > 0.5 && corr(v1, v2) < 0.8) { logger->warn("Cannot verify spectral decompose results!"); return -1; } // check the min(10, NumSample) random eigen vector and eigen value int randomCol = 10; if (randomCol > NumSample - 1) { randomCol = NumSample - 1; } v1 = matK * matU.col(randomCol); v2 = matS(randomCol, 0) * matU.col(randomCol); if (matS(randomCol, 0) > 0.5 && v1.col(0).norm() > 0.5 && v2.col(0).norm() > 0.5 && corr(v1, v2) < 0.8) { logger->warn("Cannot verify spectral decompose results!"); return -1; } #ifdef DEBUG std::string tmp = fn; tmp += ".tmp"; std::ofstream ofs(tmp.c_str(), std::ofstream::out); ofs << mat; ofs.close(); #endif // fprintf(stderr, "Kinship matrix [ %d x %d ] loaded", (int)mat.rows(), // (int)mat.cols()); if (this->matK) { delete this->matK; this->matK = NULL; } return 0; }
void obstypes_read(char fname[], int* n, obstype** types, double rfactor_base) { FILE* f = NULL; char buf[MAXSTRLEN]; int line; obstype* now = NULL; int i; assert(*n == 0); f = enkf_fopen(fname, "r"); line = 0; while (fgets(buf, MAXSTRLEN, f) != NULL) { char seps[] = " =\t\n"; char* token; line++; if (buf[0] == '#') continue; if ((token = strtok(buf, seps)) == NULL) continue; if (strcasecmp(token, "NAME") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: NAME not specified", fname, line); if (obstype_getid(*n, *types, token) >= 0) enkf_quit("%s: l.%d: type \"%s\" already specified", fname, line, token); *types = realloc(*types, (*n + 1) * sizeof(obstype)); now = &(*types)[*n]; obstype_new(now, *n, token); (*n)++; continue; } if (now == NULL) enkf_quit("%s, l.%d: NAME not specified", fname, line); if (strcasecmp(token, "ISSURFACE") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: ISSURFACE not specified", fname, line); now->issurface = read_bool(token); if (now->issurface < 0) enkf_quit("%s, l.%d: could not convert \"%s\" to boolean", fname, line, token); } else if (strcasecmp(token, "VAR") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: VAR not specified", fname, line); if (now->varname != NULL) enkf_quit("%s, l.%d: VAR already specified", fname, line); now->varname = strdup(token); } else if (strcasecmp(token, "VAR2") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: VAR2 not specified", fname, line); if (now->varname2 != NULL) enkf_quit("%s, l.%d: VAR2 already specified", fname, line); now->varname2 = strdup(token); } else if (strcasecmp(token, "OFFSET") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: OFFSET file name not specified", fname, line); if (now->offset_fname != NULL) enkf_quit("%s, l.%d: OFFSET entry already specified", fname, line); now->offset_fname = strdup(token); if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: OFFSET variable name not specified", fname, line); now->offset_varname = strdup(token); } else if (strcasecmp(token, "HFUNCTION") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: HFUNCTION not specified", fname, line); if (now->hfunction != NULL) enkf_quit("%s, l.%d: HFUNCTION already specified", fname, line); now->hfunction = strdup(token); } else if (strcasecmp(token, "MINVALUE") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: MINVALUE not specified", fname, line); if (!str2double(token, &now->allowed_min)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "MAXVALUE") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: MAXVALUE not specified", fname, line); if (!str2double(token, &now->allowed_max)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strncasecmp(token, "ASYNC", 5) == 0) { now->isasync = 1; if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: ASYNC time interval not specified", fname, line); if (!str2double(token, &now->async_tstep)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "RFACTOR") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: RFACTOR not specified", fname, line); if (!str2double(token, &now->rfactor)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "XMIN") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: XMIN not specified", fname, line); if (!str2double(token, &now->xmin)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "XMAX") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: XMAX not specified", fname, line); if (!str2double(token, &now->xmax)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "YMIN") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: YMIN not specified", fname, line); if (!str2double(token, &now->ymin)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "YMAX") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: YMAX not specified", fname, line); if (!str2double(token, &now->ymax)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "ZMIN") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: ZMIN not specified", fname, line); if (!str2double(token, &now->zmin)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else if (strcasecmp(token, "ZMAX") == 0) { if ((token = strtok(NULL, seps)) == NULL) enkf_quit("%s, l.%d: ZMAX not specified", fname, line); if (!str2double(token, &now->zmax)) enkf_quit("%s, l.%d: could not convert \"%s\" to double", fname, line, token); } else enkf_quit("%s, l.%d: unknown token \"%s\"", fname, line, token); } fclose(f); for (i = 0; i < *n; ++i) (*types)[i].rfactor *= rfactor_base; for (i = 0; i < *n; ++i) { obstype_check(&(*types)[i]); obstype_print(&(*types)[i]); } }