// [[Rcpp::export(".cyclopsReadData")]] List cyclopsReadFileData(const std::string& fileName, const std::string& modelTypeName) { using namespace bsccs; Timer timer; ModelType modelType = RcppCcdInterface::parseModelType(modelTypeName); InputReader* reader = new NewGenericInputReader(modelType, bsccs::make_shared<loggers::RcppProgressLogger>(true), // make silent bsccs::make_shared<loggers::RcppErrorHandler>()); reader->readFile(fileName.c_str()); // TODO Check for error XPtr<ModelData> ptr(reader->getModelData()); const std::vector<double>& y = ptr->getYVectorRef(); double total = std::accumulate(y.begin(), y.end(), 0.0); // delete reader; // TODO Test double time = timer(); List list = List::create( Rcpp::Named("cyclopsDataPtr") = ptr, Rcpp::Named("timeLoad") = time, Rcpp::Named("debug") = List::create( Rcpp::Named("totalY") = total ) ); return list; }
int main (const int argc, char const * const argv[]) { #ifndef DENORMALS _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON); _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON); #endif auto pairhmm = Pairhmm< //PairhmmScalarImpl<float>, //PairhmmScalarImpl<double> //PairhmmSSEFloatImpl, //PairhmmAVXFloatImpl, //PairhmmAVXDoubleImpl PairhmmAVXFloat2DiagsImpl, PairhmmAVXDouble2DiagsImpl >{}; InputReader<TestcaseIterator> reader {}; if (argc == 2) reader.from_file(argv[1]); double computation_time = 0.f; Chronos time; for (auto& testcase : reader) { time.reset(); auto results = pairhmm.calculate(testcase); computation_time += time.elapsed(); for (auto x : results) cout << x << endl; } std::cerr << "done in " << computation_time << "ms\n"; return 0; }
/** Reads a length value including a trailing unit specifier and returns it. */ static Length read_length (InputReader &ir) { Length length; ir.skipSpace(); if (!isalpha(ir.peek())) { double val = ir.getDouble(); string unit = isalpha(ir.peek()) ? ir.getString(2) : "pt"; length = Length(val, unit); } return length; }
/** Handles the "point" command that adds a point to the point list. */ void EmSpecialHandler::point (InputReader &ir, SpecialActions &actions) { DPair pos(actions.getX(), actions.getY()); int n = ir.getInt(); if (ir.getPunct() == ',') { pos.x(ir.getDouble()); if (ir.getPunct() == ',') pos.y(ir.getDouble()); } _points[n] = pos; }
/** Reads a length (value + unit) and returns its value in PS points (bp). * If no unit is specified, TeX points are assumed. */ static double read_length (InputReader &in) { double val = in.getDouble(); string unitstr; if (isalpha(in.peek())) unitstr += in.get(); if (isalpha(in.peek())) unitstr += in.get(); Length::Unit unit = Length::Unit::PT; try { unit = Length::stringToUnit(unitstr); } catch (UnitException &e) { } return Length(val, unit).bp(); }
int main(int argc, char **argv) { QApplication app(argc,argv); //QApplication::setStyle(QStyleFactory::create("Plastique")); QApplication::setPalette(QApplication::style()->standardPalette()); // MainUser mainUser; //mainUser.show(); InputReader inputDialog; inputDialog.show(); return app.exec(); }
void DvisvgmSpecialHandler::preprocessRawDef (InputReader &ir) { if (_currentMacro == _macros.end()) return; string str = ir.getLine(); if (!str.empty()) _currentMacro->second.push_back(string("D")+str); }
int main(int argc, char* argv[]) { InputReader iReader; Validator validator; Grader grader; OutputWriter oWriter; iReader.scanSubmissionMethod(argc); iReader.scanInput(); validator.validateInput(iReader.getInput()); grader.grade(iReader.getInput()); oWriter.displayResult(grader.getGrade()); return 0; }
void DvisvgmSpecialHandler::processRawDef (InputReader &ir, SpecialActions *actions) { if (_nestingLevel == 0) { string str = ir.getLine(); if (!str.empty()) { expand_constants(str, actions); actions->appendToDefs(new XMLTextNode(str)); } } }
void DvisvgmSpecialHandler::processImg (InputReader &ir, SpecialActions *actions) { if (actions) { const double pt2bp = 72/72.27; double w = ir.getDouble()*pt2bp; double h = ir.getDouble()*pt2bp; string f = ir.getString(); update_bbox(w, h, 0, actions); XMLElementNode *img = new XMLElementNode("image"); img->addAttribute("x", actions->getX()); img->addAttribute("y", actions->getY()); img->addAttribute("width", w); img->addAttribute("height", h); img->addAttribute("xlink:href", f); if (!actions->getMatrix().isIdentity()) img->addAttribute("transform", actions->getMatrix().getSVG()); actions->appendToPage(img); } }
void DvisvgmSpecialHandler::processRawDef (InputReader &ir, SpecialActions &actions) { if (_nestingLevel == 0) { string xml = ir.getLine(); if (!xml.empty()) { expand_constants(xml, actions); _defsParser.parse(xml, actions); } } }
static string read_entry (InputReader &in) { string entry; bool accept_slashes=true; while (!in.eof() && ((in.peek() == '/' && accept_slashes) || valid_name_char(in.peek()))) { if (in.peek() != '/') accept_slashes = false; entry += char(in.get()); } if (entry.length() > 1) { // strip leading slashes // According to the PostScript specification, a single slash without further // following characters is a valid name. size_t n=0; while (n < entry.length() && entry[n] == '/') n++; entry = entry.substr(n); } return entry; }
int main (int argc, char** argv) { if (argc < 2) { std::cout << "Usage: " << argv[0] << " <Subread Filename>" << std::endl; exit(1); } // Read the subread parameters from the file std::ifstream subread_file; unsigned int num_reads; unsigned int num_subreads_per_read; unsigned int subread_length; subread_file.open(argv[1]); subread_file.read((char *) (&num_reads), sizeof(unsigned int )); subread_file.read((char *) (&num_subreads_per_read), sizeof(unsigned int )); subread_file.read((char *) (&subread_length), sizeof(unsigned int )); unsigned int num_itcs = num_subreads_per_read * 2; assert(num_itcs % num_subreads_per_read == 0); // Store the subreads into lists to be used later std::queue<uint64_t>* subread_list = new std::queue<uint64_t>[num_itcs]; unsigned int cur_subread = 0; while (cur_subread < num_reads * num_subreads_per_read) { uint64_t subread; unsigned int cur_itc = cur_subread % num_itcs; subread_file.read((char *) (&subread), sizeof(uint64_t)); subread_list[cur_itc].push(subread); cur_subread++; } subread_file.close(); // Instantiate the input reader InputReader* ir = new InputReader(argv[1], num_itcs); uint64_t start_cycle = ir->cycle_count(); uint64_t num_subreads_read = 0; while (num_subreads_read < num_reads * num_subreads_per_read) { for (unsigned int i = 0; i < num_itcs; i++) { if (ir->SubReadReady(i)) { SubRead sr = ir->SubReadRequest(i); assert(sr.data == subread_list[i].front()); subread_list[i].pop(); num_subreads_read++; } } ir->NextClockCycle(); } // Check that workload is done assert(ir->Done() == true); std::cout << "Conflict test took " << ir->cycle_count() - start_cycle << " cycles" << std::endl; std::cout << "Input Reader tests complete!" << std::endl; return 0; }
/** Reads characters from an input stream until the pattern string or EOF is reached. * The matching string is read too if found. An empty pattern matches any character, i.e. * reading stops after the first character. * @return true if the pattern was found */ bool StringMatcher::match (InputReader &ir) { int c; int i=0; const int len = static_cast<int>(_pattern.length()); _charsRead = 0; while ((c = ir.get()) >= 0) { _charsRead++; while (i >= 0 && c != _pattern[i]) i = _borders[i]; if (++i == len) return true; } return false; }
/** Reads characters from an input stream until the pattern string or EOF is reached * and returns them as a string. The matching string is also appended to the returned string. */ string StringMatcher::read (InputReader &ir) { string ret; int c; int i=0; const int len = static_cast<int>(_pattern.length()); while ((c = ir.get()) >= 0) { ret += char(c); while (i >= 0 && c != _pattern[i]) i = _borders[i]; if (++i == len) break; } _charsRead = ret.length(); return ret; }
void DvisvgmSpecialHandler::preprocessRawSet (InputReader &ir) { _nestingLevel++; string id = ir.getString(); if (id.empty()) throw SpecialException("definition of unnamed SVG fragment"); if (_nestingLevel > 1) throw SpecialException("nested definition of SVG fragment '" + id + "'"); _currentMacro = _macros.find(id); if (_currentMacro != _macros.end()) { _currentMacro = _macros.end(); throw SpecialException("redefinition of SVG fragment '" + id + "'"); } pair<string, StringVector> entry(id, StringVector()); pair<MacroMap::iterator, bool> state = _macros.insert(entry); _currentMacro = state.first; }
void DvisvgmSpecialHandler::processImg (InputReader &ir, SpecialActions &actions) { try { Length w = read_length(ir); Length h = read_length(ir); string f = ir.getString(); update_bbox(w, h, Length(0), false, actions); auto img = util::make_unique<XMLElement>("image"); img->addAttribute("x", actions.getX()); img->addAttribute("y", actions.getY()); img->addAttribute("width", w.bp()); img->addAttribute("height", h.bp()); img->addAttribute("xlink:href", f); if (!actions.getMatrix().isIdentity()) img->addAttribute("transform", actions.getMatrix().toSVG()); actions.svgTree().appendToPage(std::move(img)); } catch (const UnitException &e) { throw SpecialException(string("dvisvgm:img: ") + e.what()); } }
/** Handles the "line" command that draws a straight line between two points * from the point list. */ void EmSpecialHandler::line (InputReader &ir, SpecialActions& actions) { int pointnum1 = ir.getInt(); int cut1 = 'p'; if (isalpha(ir.peek())) cut1 = ir.get(); ir.getPunct(); int pointnum2 = ir.getInt(); int cut2 = 'p'; if (isalpha(ir.peek())) cut2 = ir.get(); double linewidth = _linewidth; if (ir.getPunct() == ',') linewidth = read_length(ir); auto it1=_points.find(pointnum1); auto it2=_points.find(pointnum2); if (it1 != _points.end() && it2 != _points.end()) create_line(it1->second, it2->second, char(cut1), char(cut2), linewidth, actions); else { // Line endpoints don't necessarily have to be defined before // a line definition. If a point isn't defined yet, we put the line // in a wait list and process the lines at the end of the page. _lines.emplace_back(Line(pointnum1, pointnum2, char(cut1), char(cut2), linewidth)); } }
void DvisvgmSpecialHandler::processRawPut (InputReader &ir, SpecialActions &actions) { if (_nestingLevel > 0) return; string id = ir.getString(); auto it = _macros.find(id); if (it == _macros.end()) throw SpecialException("undefined SVG fragment '" + id + "' referenced"); StringVector &defvector = it->second; for (string &defstr : defvector) { char &type = defstr[0]; string def = defstr.substr(1); if ((type == 'P' || type == 'D') && !def.empty()) { expand_constants(def, actions); if (type == 'P') _pageParser.parse(def, actions); else { // type == 'D' _defsParser.parse(def, actions); type = 'L'; // locked } } } }
void DvisvgmSpecialHandler::processRawPut (InputReader &ir, SpecialActions *actions) { if (_nestingLevel > 0) return; string id = ir.getString(); MacroMap::iterator it = _macros.find(id); if (it == _macros.end()) throw SpecialException("undefined SVG fragment '" + id + "' referenced"); StringVector &defs = it->second; for (StringVector::iterator defs_it=defs.begin(); defs_it != defs.end(); ++defs_it) { char &type = defs_it->at(0); string def = defs_it->substr(1); if ((type == 'P' || type == 'D') && !def.empty()) { expand_constants(def, actions); if (type == 'P') actions->appendToPage(new XMLTextNode(def)); else { // type == 'D' actions->appendToDefs(new XMLTextNode(def)); type = 'L'; // locked } } } }
/** Evaluates the special dvisvgm:bbox. * variant 1: dvisvgm:bbox [r[el]] <width> <height> [<depth>] * variant 2: dvisvgm:bbox a[bs] <x1> <y1> <x2> <y2> * variant 3: dvisvgm:bbox f[ix] <x1> <y1> <x2> <y2> * variant 4: dvisvgm:bbox n[ew] <name> */ void DvisvgmSpecialHandler::processBBox (InputReader &ir, SpecialActions *actions) { const double pt2bp = 72/72.27; ir.skipSpace(); int c = ir.peek(); if (isalpha(c)) { while (!isspace(ir.peek())) // skip trailing characters ir.get(); if (c == 'n') { ir.skipSpace(); string name; while (isalnum(ir.peek())) name += char(ir.get()); ir.skipSpace(); if (!name.empty() && ir.eof()) actions->bbox(name, true); // create new user box } else if (c == 'a' || c == 'f') { double p[4]; for (int i=0; i < 4; i++) p[i] = ir.getDouble()*pt2bp; BoundingBox b(p[0], p[1], p[2], p[3]); if (c == 'a') actions->embed(b); else { actions->bbox() = b; actions->bbox().lock(); } } } else c = 'r'; // no mode specifier => relative box parameters if (c == 'r') { double w = ir.getDouble()*pt2bp; double h = ir.getDouble()*pt2bp; double d = ir.getDouble()*pt2bp; update_bbox(w, h, d, actions); } }
/** Evaluates the special dvisvgm:bbox. * variant 1: dvisvgm:bbox [r[el]] <width> <height> [<depth>] [transform] * variant 2: dvisvgm:bbox a[bs] <x1> <y1> <x2> <y2> [transform] * variant 3: dvisvgm:bbox f[ix] <x1> <y1> <x2> <y2> [transform] * variant 4: dvisvgm:bbox n[ew] <name> * variant 5: dvisvgm:bbox lock | unlock */ void DvisvgmSpecialHandler::processBBox (InputReader &ir, SpecialActions &actions) { ir.skipSpace(); if (ir.check("lock")) actions.bbox().lock(); else if (ir.check("unlock")) actions.bbox().unlock(); else { int c = ir.peek(); try { if (!isalpha(c)) c = 'r'; // no mode specifier => relative box parameters else { while (!isspace(ir.peek())) // skip trailing characters ir.get(); if (c == 'n') { // "new": create new local bounding box ir.skipSpace(); string name; while (isalnum(ir.peek())) name += char(ir.get()); ir.skipSpace(); if (!name.empty() && ir.eof()) actions.bbox(name, true); // create new user box } else if (c == 'a' || c == 'f') { // "abs" or "fix" Length lengths[4]; for (Length &len : lengths) len = read_length(ir); BoundingBox b(lengths[0], lengths[1], lengths[2], lengths[3]); ir.skipSpace(); if (ir.check("transform")) b.transform(actions.getMatrix()); if (c == 'a') actions.embed(b); else { actions.bbox() = b; actions.bbox().lock(); } } } if (c == 'r') { Length w = read_length(ir); Length h = read_length(ir); Length d = read_length(ir); ir.skipSpace(); update_bbox(w, h, d, ir.check("transform"), actions); } } catch (const UnitException &e) { throw SpecialException(string("dvisvgm:bbox: ") + e.what()); } } }
void CommandLine::handle_version (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getBoolArg(ir, opt, longopt, _version_arg)) _version_given = true; }
void CommandLine::handle_trace_all (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getBoolArg(ir, opt, longopt, _trace_all_arg)) _trace_all_given = true; }
void CommandLine::handle_progress (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getDoubleArg(ir, opt, longopt, _progress_arg)) _progress_given = true; }
void CommandLine::handle_no_specials (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getStringArg(ir, opt, longopt, _no_specials_arg)) _no_specials_given = true; }
void CommandLine::handle_cache (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getStringArg(ir, opt, longopt, _cache_arg)) _cache_given = true; }
/** Parses a single line in dvipdfmx mapfile format. * @param[in] ir the input stream must be assigned to this reader */ void MapLine::parseDVIPDFMLine (InputReader &ir) { ir.skipSpace(); if (ir.peek() != '-') { _encname = ir.getString(); if (_encname == "default" || _encname == "none") _encname.clear(); } ir.skipSpace(); if (ir.peek() != '-') _fontfname = ir.getString(); if (!_fontfname.empty()) { parseFilenameOptions(_fontfname); } ir.skipSpace(); while (ir.peek() == '-') { ir.get(); int option = ir.get(); if (!isprint(option)) throw MapLineException("option character expected"); ir.skipSpace(); switch (option) { case 's': // slant if (!ir.parseDouble(_slant)) throw_number_expected('s'); break; case 'e': // extend if (!ir.parseDouble(_extend)) throw_number_expected('e'); break; case 'b': // bold if (!ir.parseDouble(_bold)) throw_number_expected('b'); break; case 'r': //remap (deprecated) break; case 'i': // ttc index if (!ir.parseInt(_fontindex, false)) throw_number_expected('i', true); break; case 'p': // UCS plane int dummy; if (!ir.parseInt(dummy, false)) throw_number_expected('p', true); break; case 'u': // to unicode ir.getString(); break; case 'v': // stemV int stemv; if (!ir.parseInt(stemv, true)) throw_number_expected('v', true); break; case 'm': // map single chars ir.skipUntil("-"); break; case 'w': // writing mode (horizontal=0, vertical=1) int vertical; if (!ir.parseInt(vertical, false)) throw_number_expected('w', true); break; default: ostringstream oss; oss << "invalid option: -" << option; throw MapLineException(oss.str()); } ir.skipSpace(); } }
/** Parses a single line in dvips mapfile format. * @param[in] ir the input stream must be assigned to this reader */ void MapLine::parseDVIPSLine (InputReader &ir) { ir.skipSpace(); if (ir.peek() != '<' && ir.peek() != '"') _psname = ir.getString(); ir.skipSpace(); while (ir.peek() == '<' || ir.peek() == '"') { if (ir.peek() == '<') { ir.get(); if (ir.peek() == '[') ir.get(); string name = ir.getString(); if (name.length() > 4 && name.substr(name.length()-4) == ".enc") _encname = name.substr(0, name.length()-4); else _fontfname = name; } else { // ir.peek() == '"' => list of PS font operators string options = ir.getQuotedString('"'); StringInputBuffer sib(options); BufferInputReader sir(sib); while (!sir.eof()) { double number; if (sir.parseDouble(number)) { // operator with preceding numeric parameter (value opstr) string opstr = sir.getString(); if (opstr == "SlantFont") _slant = number; else if (opstr == "ExtendFont") _extend = number; } else { // operator without parameter => skip for now sir.getString(); } } } ir.skipSpace(); } }
void CommandLine::handle_zip (InputReader &ir, const Option &opt, bool longopt) { if (ir.eof() || getIntArg(ir, opt, longopt, _zip_arg)) _zip_given = true; }