int main (int argc, const char* argv[] ) { ucam::util::initLogger ( argc, argv ); FORCELINFO ( argv[0] << " starts!" ); ucam::util::RegistryPO rg ( argc, argv ); FORCELINFO ( rg.dump ( "CONFIG parameters:\n=====================", "=====================" ) ) ; ucam::util::PatternAddress<unsigned> pi (rg.get<std::string> (HifstConstants::kInput) ); ucam::util::PatternAddress<unsigned> po (rg.get<std::string> (HifstConstants::kOutput) ); for ( ucam::util::IntRangePtr ir (ucam::util::IntRangeFactory ( rg, HifstConstants::kRangeOne ) ); !ir->done(); ir->next() ) { fst::VectorFst<fst::StdArc> *mfst = fst::VectorFstRead<fst::StdArc> (pi ( ir->get() ) ); if (!mfst) return 1; TopSort (mfst); boost::multiprecision::uint128_t j = countstrings<fst::StdArc, boost::multiprecision::uint128_t> (*mfst); std::stringstream ss; ss << j; ucam::util::oszfstream o (po (ir->get() ), true); o << ss.str() << std::endl; LINFO ( pi (ir->get() ) << ":" << ss.str() ) ; o.close(); delete mfst; } FORCELINFO ( argv[0] << " ends!" ); }
void PD_UI_DissBattle::insult(bool _isEffective, std::wstring _word){ PD_ResourceManager::scenario->getAudio(TIMER)->sound->stop(); if(!_isEffective) { PD_ResourceManager::scenario->getAudio(FAIL_INSULT)->sound->play(); }else { sweet::NumberUtils::randomItem(succeedInsultSounds)->play(); int randComp = sweet::NumberUtils::randomInt(1, NUM_COMPLIMENTS); complimentBubble->mesh->replaceTextures(PD_ResourceManager::scenario->getTexture("DISS-BATTLE-COMPLIMENT" + std::to_string(randComp))->texture); complimentBubbleTimer = 0.f; complimentBubble->setVisible(true); } // Make resulting insult const std::string constText = insultGenerator.playerInsult; std::regex rg(insultGenerator.playerBlank); std::string text = std::regex_replace(constText, rg, std::string(_word.begin(), _word.end())); playerBubbleText->setText(text); playerBubbleLayout->removeChild(playerBubbleOptions); playerBubbleText->setRationalWidth(1.f, playerBubbleText->nodeUIParent); playerBubble->invalidateLayout(); playerResult = true; countButtonPresses(_isEffective, true); countInsultAccuracy(playerAnswerTimer); playerResultEffective = _isEffective; sweet::Event * e = new sweet::Event("insult"); e->setIntData("success", _isEffective); eventManager->triggerEvent(e); }
static t_std_error dn_nas_get_phy_media_default_setting(PLATFORM_MEDIA_TYPE_t media_type, cps_api_object_t obj) { cps_api_get_params_t gp; cps_api_get_request_init(&gp); cps_api_get_request_guard rg(&gp); cps_api_object_t media_obj = cps_api_object_list_create_obj_and_append(gp.filters); t_std_error rc = STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_FAIL, 0); do { if (!cps_api_key_from_attr_with_qual(cps_api_object_key(media_obj), BASE_MEDIA_MEDIA_INFO_OBJ, cps_api_qualifier_OBSERVED)) { break; } cps_api_set_key_data_uint(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, &media_type, sizeof(media_type)); cps_api_object_attr_add_u32(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, media_type); if (cps_api_get(&gp) != cps_api_ret_code_OK) break; if (0 == cps_api_object_list_size(gp.list)) break; media_obj = cps_api_object_list_get(gp.list,0); if (!cps_api_object_clone(obj, media_obj)) { break; } rc = STD_ERR_OK; } while(0); return rc; }
int main ( int argc, const char* argv[] ) { ucam::util::initLogger ( argc, argv ); FORCELINFO ( argv[0] << " starts!" ); ucam::util::RegistryPO rg ( argc, argv ); FORCELINFO ( rg.dump ( "CONFIG parameters:\n=====================", "=====================" ) ); if (rg.get<std::string> (HifstConstants::kAction) == HifstConstants::kActionProjectweight2 ) { run<fst::LexStdArc , fst::LexStdArc , fst::GenericWeightMapper<fst::LexStdArc, fst::LexStdArc, fst::MakeWeight2<fst::LexStdArc> >, fst::MakeWeight2<fst::LexStdArc> > (rg); } else if (rg.get<std::string> (HifstConstants::kAction) == HifstConstants::kActionLex2std) { run<fst::LexStdArc , fst::StdArc , fst::GenericWeightMapper<fst::LexStdArc, fst::StdArc, fst::LexToStd >, fst::LexToStd > (rg); } else if (rg.get<std::string> (HifstConstants::kAction) == HifstConstants::kActionStd2lex) { run<fst::StdArc , fst::LexStdArc , fst::GenericWeightMapper<fst::StdArc, fst::LexStdArc, fst::MakeWeight2<fst::LexStdArc> >, fst::MakeWeight2<fst::LexStdArc> > (rg); } else { LERROR ("Action not recognized! Check program option."); } FORCELINFO ( argv[0] << " finished!" ); }
int scc(Graph &graph, vector<int> &cmp) { int V = graph.size(); vector<vector<int>> g(V), rg(V); vector<int> vs; vector<bool> used(V, false); cmp.resize(V); REP(i,V) { for (Edge e: graph[i]) { g[i].push_back(e.dest); rg[e.dest].push_back(i); } } function<void(int)> dfs = [&g, &vs, &used, &dfs](int v) { used[v] = true; for (int i: g[v]) if (!used[i]) dfs(i); vs.push_back(v); }; function<void(int,int)> rdfs = [&rg, &cmp, &used, &rdfs](int v, int k) { used[v] = true; cmp[v] = k; for (int i: rg[v]) if (!used[i]) rdfs(i, k); }; REP(v,V) if (!used[v]) dfs(v); used = vector<bool>(V, false); reverse(ALL(vs)); int k = 0; for(int i: vs) if (!used[i]) rdfs(i, k++); return k; }
std::size_t getCpuL2CacheSize() { std::size_t r = 1024*1024; //1MiB should be reasonable default for modern processors #if DEFAULT_L2_CACHE_SIZE > 1024 r = DEFAULT_L2_CACHE_SIZE; #endif std::string s = ""; #if _linux try{ std::regex rg("cache size[[:space:]]*:[[:space:]]*([0-9]*)[[:space:]]"); s = IOUtil::fileGrep("/proc/cpuinfo", rg, true, 1); int si = std::stoi(s); if(si > 0) r = 1024 * (size_t)si; }catch(std::regex_error& e){ //beware of pre-4.9 gcc! see for example https://stackoverflow.com/a/12665408 // std::cerr << e.what() << e.code() << std::endl; } #elif _MSC_VER int test_cpuInfo[4] = {-1}; __cpuid(test_cpuInfo, 0x80000000); if(test_cpuInfo[3] > 5) { int cpuInfo[4] = {-1}; __cpuid(cpuInfo, 0x80000006); size_t sz = cpuInfo[3] & 0xf; if(sz > 0) r = sz * 1024; } #endif return r; }
std::string getCpuSpec() { std::string r = ""; #if __linux try{ std::regex rg("model name[[:space:]]*:[[:space:]]*(.*)"); r = IOUtil::fileGrep("/proc/cpuinfo", rg, true, 1); }catch(std::regex_error& e){ //beware of pre-4.9 gcc! see for example https://stackoverflow.com/a/12665408 // std::cerr << e.what() << e.code() << std::endl; } return r; #elif _MSC_VER int cpuInfo[4] = {-1}; __cpuid(cpuInfo, 0); char vendor[13]; vendor[12] = 0; const char * ptr= reinterpret_cast<const char *>(&cpuInfo[1]); for(int i = 0; i < 12; i++) vendor[i] = ptr[i]; # ifdef HAVE_BOOST r = str(boost::format("cpuid: %08x %08x %08x %08x %s") % cpuInfo[0] % cpuInfo[1] % cpuInfo[2] % cpuInfo[3] % vendor); # else r.append("cpuid: "); r.append(IOUtil::to_string_hex(cpuInfo[0])).append(" ").append(IOUtil::to_string_hex(cpuInfo[1])).append(" "); r.append(IOUtil::to_string_hex(cpuInfo[2])).append(" ").append(IOUtil::to_string_hex(cpuInfo[3])).append(" "); r.append(vendor); # endif return r; #else return "Unknown OS"; #endif }
void dtkPieChart::paintEvent(QPaintEvent *ev) { QHash<QString, int>::const_iterator it; int total = 0; for(it = d->values.begin(); it != d->values.end(); ++it) total += it.value(); QPainter p(this); p.setRenderHint(QPainter::Antialiasing, true); int height = rect().height(); QRect pieRect(0, 0, height, height); QRect legendRect = rect(); legendRect.setLeft(pieRect.width()); legendRect.adjust(10,10,-10,-10); int lastAngleOffset = 0; int currentPos = 0; for(it = d->values.begin(); it != d->values.end(); ++it) { int value = it.value(); QString text = it.key(); int angle = (int)(16*360*(value/(double)total)); QRadialGradient rg(pieRect.center(), pieRect.width()/2, pieRect.topLeft()); rg.setColorAt(0, Qt::white); rg.setColorAt(1, d->colors[text]); p.setBrush(rg); QPen pen = p.pen(); p.setPen(Qt::NoPen); p.drawPie(pieRect, lastAngleOffset, angle); lastAngleOffset += angle; int fh = fontMetrics().height(); QRect legendEntryRect(0,(fh*1.5)*currentPos,fh,fh); currentPos++; legendEntryRect.translate(legendRect.topLeft()); QLinearGradient lg(legendEntryRect.topLeft(), legendEntryRect.bottomRight()); lg.setColorAt(0, d->colors[text]); lg.setColorAt(1, Qt::white); p.setBrush(QBrush(lg)); p.drawRect(legendEntryRect); QPoint textStart = legendEntryRect.topRight(); textStart = textStart + QPoint(fontMetrics().width('x'), 0); QPoint textEnd(legendRect.right(), legendEntryRect.bottom()); QRect textEntryRect(textStart, textEnd); p.setPen(pen); p.drawText(textEntryRect, Qt::AlignVCenter, text); } }
/* * CTxtEdit::GetClipboardData * * @mfunc return an data transfer object for the indicated * range * * @rdesc * HRESULT Success code. */ STDMETHODIMP CTxtEdit::GetClipboardData( CHARRANGE *lpchrg, //@parm the range of text to use DWORD reco, //@parm operation the data is for LPDATAOBJECT *lplpdataobj) //@parm where to put the data object { TRACEBEGIN(TRCSUBSYSOLE, TRCSCOPEEXTERN, "CTxtEdit::GetClipboardData"); CCallMgr callmgr(this); HRESULT hr; LONG cpMin, cpMost; CLightDTEngine * pldte = GetDTE(); //Make sure cpMin and cpMost are within the current text limits. //Interpret neg. value for cpMin as the beginning of the text, //and neg. value for cpMax as the end of the text. If a char range //is not given use the current selection. if(lpchrg) { LONG cchText; cchText = (LONG)GetTextLength(); cpMin = max(0, lpchrg->cpMin); cpMin = min(cchText, lpchrg->cpMin); cpMost = lpchrg->cpMost; if(lpchrg->cpMost < 0 || lpchrg->cpMost > cchText) cpMost = cchText; } else { CTxtSelection * psel = GetSel(); psel->GetRange(cpMin, cpMost); } //Make sure this is a valid range. if(cpMin >= cpMost) { *lplpdataobj = NULL; return cpMin == cpMost ? NOERROR : ResultFromScode(E_INVALIDARG); } CTxtRange rg(this, cpMin, cpMin-cpMost); //We don't use reco for anything. hr = pldte->RangeToDataObject(&rg, SF_RTF, lplpdataobj); #ifdef DEBUG if(hr != NOERROR) TRACEERRSZSC("GetClipboardData", E_OUTOFMEMORY); #endif return hr; }
void ShuffleCommand :: Shuffle( IOManager & io ) { ALib::RandGen rg( mSeed ); int nout = mCount; int last = mRows.size(); for ( unsigned int i = 0; i < mRows.size() && nout-- > 0; i++ ) { int pos = rg.NextInt( 0, last ); io.WriteRow( mRows[pos] ); mRows[pos].swap( mRows[--last] ); } }
int main(int,char**) { ////////////////////////////////////////////////////////// /// create a .csv file : ///////////////////////////////// ////////////////////////////////////////////////////////// std::ofstream writer("out_bkg.csv"); if(writer.fail()) { std::cout << "can't open out_bkg.csv." << std::endl; return EXIT_FAILURE; } unsigned int entries = 1000; tools::random::gauss rg(1,2); tools::randf::bw rbw(0,1); ////////////////////////////////////////////////////////// /// create a ntuple_booking object : ///////////////////// ////////////////////////////////////////////////////////// tools::ntuple_booking nbk; nbk.add_column<unsigned int>("index"); nbk.add_column<double>("rgauss"); nbk.add_column<float>("rbw"); //nbk.add_column<bool>("not_handled"); ////////////////////////////////////////////////////////// /// create and write a ntuple : ////////////////////////// ////////////////////////////////////////////////////////// tools::wcsv::ntuple ntu(writer,std::cout,nbk); //default sep is ',' if(ntu.columns().size()) { tools::wcsv::ntuple::column<unsigned int>* col_index = ntu.find_column<unsigned int>("index"); tools::wcsv::ntuple::column<double>* col_rgauss = ntu.find_column<double>("rgauss"); tools::wcsv::ntuple::column<float>* col_rbw = ntu.find_column<float>("rbw"); // fill : for(unsigned int count=0;count<entries;count++) { col_index->fill(count); col_rgauss->fill(rg.shoot()); col_rbw->fill(rbw.shoot()); ntu.add_row(); // it will write columns data as a row in the file. } } ////////////////////////////////////////////////////////// /// close file : ///////////////////////////////////////// ////////////////////////////////////////////////////////// writer.close(); return EXIT_SUCCESS; }
void CommandLine::parse_random(CNFFormula & f){ if(!vm->count("n") || !vm->count("k")){ std::cerr << "Need to provide n and k for random generator" << std::endl; throw CLIException("n or k was not provided where needed"); } unsigned int n = (*vm)["n"].as<unsigned int>(); unsigned int k = (*vm)["k"].as<unsigned int>(); unsigned int p = (*vm)["random"].as<unsigned int>(); RandomSatGenerator rg(n, k, p); rg.generate_formula(f); }
int main ( int argc, const char *argv[] ) { ucam::util::initLogger ( argc, argv ); FORCELINFO ( argv[0] << " starts!" ); ucam::util::RegistryPO rg ( argc, argv ); FORCELINFO ( rg.dump ( "CONFIG parameters:\n=====================" , "=====================" ) ); ( ucam::util::Runner2<ucam::lmbr::SingleThreadedLmbrTask<> , ucam::lmbr::MultiThreadedLmbrTask<> > ( rg ) ) (); FORCELINFO ( argv[0] << " ends!" ); return 0; }
//--------------------------------------------------------------------------- void __fastcall TMapDialog::DrawVertGraph(const double *sol, const int *stat, int psol, int psols, int psole, int nsol, int currentstat) { TColor color[]={clWhite,clGreen,CLORANGE,clFuchsia,clBlue,clRed}; TCanvas *c=Plot->Canvas; TRect rg(GRPHMARGIN,Plot->Height-GRPHEIGHT-2,Plot->Width-GRPHMARGIN,Plot->Height-2); TPoint *p=new TPoint[nsol],p0; TColor *col=new TColor[nsol]; int n=0,m=0; for (int i=psols;i!=psole;) { n++; if (++i>=nsol) i=0; } for (int i=psols;i!=psole;) { p[m]=PosToGraphP(sol+i*3,sol+psol*3,nsol-n+m,nsol,rg); if (i==psol) p0=p[m]; col[m++]=color[stat[i]]; if (++i>=nsol) i=0; } c->Brush->Style=bsSolid; c->Brush->Color=clWhite; c->FillRect(rg); c->Pen->Color=clSilver; c->Pen->Style=psSolid; c->Rectangle(rg); c->MoveTo(rg.Left,(rg.Top+rg.Bottom)/2); c->LineTo(rg.Right,(rg.Top+rg.Bottom)/2); c->Pen->Color=clSilver; c->MoveTo(p0.x,rg.Bottom); c->LineTo(p0.x,rg.Top); for (int i=0;i<nsol;i++) { if (i%100) continue; int x=rg.Left+(rg.Right-rg.Left)*((nsol+i-psole)%nsol)/nsol; int y=(rg.Top+rg.Bottom)/2; c->MoveTo(x,y-HISSIZE); c->LineTo(x,y+HISSIZE); } int i,j; for (i=0;i<m;i=j) { for (j=i;j<m;j++) { if (p[j].y<rg.Top+HISSIZE/2||rg.Bottom-HISSIZE/2<p[j].y) break; } if (i<j) c->Polyline(p+i,j-i-1); for (;j<m;j++) { if (rg.Top+HISSIZE/2<=p[j].y&&p[j].y<=rg.Bottom-HISSIZE/2) break; } } for (int i=0;i<m;i++) { if (p[i].y<rg.Top+HISSIZE/2||rg.Bottom-HISSIZE/2<p[i].y) continue; DrawCircle(p[i],HISSIZE,col[i],col[i]); } DrawCircle(p0,HISSIZE+6,clBlack,color[currentstat]); delete [] p; delete [] col; }
size_t ManagerEvent::random() { static boost::mutex mtxThis; boost::mutex::scoped_lock lock( mtxThis ); static boost::mt19937 gen( 12345 ); static boost::uniform_int<> uni( 0, INT_MAX ); static boost::variate_generator< boost::mt19937&, boost::uniform_int<> > rg( gen, uni ); return rg(); }
void HighlightButton::paintEvent(QPaintEvent *) { QPainter painter(this); painter.translate(width() / 2, height() / 2); painter.setRenderHint(QPainter::Antialiasing); painter.setPen(Qt::transparent); painter.fillRect(-width(), -height(), width() * 2, height() * 2, Qt::gray); int radius = 100; // 外边框 QLinearGradient lg1(0, -radius, 0, radius); lg1.setColorAt(0, QColor(255, 255, 255)); lg1.setColorAt(1, QColor(166, 166, 166)); painter.setBrush(lg1); painter.drawEllipse(-radius, -radius, radius << 1, radius << 1); // 内边框 radius -= 13; QLinearGradient lg2(0, -radius, 0, radius); lg2.setColorAt(0, QColor(155, 155, 155)); lg2.setColorAt(1, QColor(255, 255, 255)); painter.setBrush(lg2); painter.drawEllipse(-radius, -radius, radius << 1, radius << 1); // 内部的圆 radius -= 4; QRadialGradient rg(0, 0, radius); rg.setColorAt(0, QColor(245, 0, 0)); rg.setColorAt(0.6, QColor(210, 0, 0)); rg.setColorAt(1, QColor(140, 0, 0)); painter.setBrush(rg); painter.drawEllipse(-radius, -radius, radius << 1, radius << 1); // 高光 radius -= 3; QPainterPath path; path.addEllipse(-radius, -radius - 2, radius << 1, radius << 1); QPainterPath bigEllipse; radius *= 2; bigEllipse.addEllipse(-radius, -radius + 140, radius << 1, radius << 1); path -= bigEllipse; QLinearGradient lg3(0, -radius / 2, 0, 0); lg3.setColorAt(0, QColor(255, 255, 255, 220)); lg3.setColorAt(1, QColor(255, 255, 255, 30)); painter.setBrush(lg3); painter.drawPath(path); }
void* enqueue (void* argument) { struct ThreadMeta* eqdata = (struct ThreadMeta*) argument; double const exp_dist_lambda = eqdata -> l; int seed = std::chrono::system_clock::now().time_since_epoch().count(); std::default_random_engine rg(seed); std::exponential_distribution <double> dist(exp_dist_lambda); for (int i = 0; i < eqdata -> count; i++) { double t1d = dist(rg); int t1 = (useconds_t)(t1d * 1e6); int x = rand() % 10000; std::chrono::microseconds ms1 = std::chrono::duration_cast <std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()); eqdata -> q -> enq(x); std::chrono::microseconds ms2 = std::chrono::duration_cast <std::chrono::microseconds> (std::chrono::system_clock::now().time_since_epoch()); std::string vecstring = std::to_string(i + 1); vecstring = vecstring + suffix(i + 1); vecstring = vecstring + " Enq("; vecstring = vecstring + std::to_string(x); vecstring = vecstring + ").inv at "; vecstring = vecstring + std::to_string(ms1.count()); list.push_back(vecstring); vecstring = ""; vecstring = std::to_string(i + 1); vecstring = vecstring + suffix(i + 1); vecstring = vecstring + " Enq("; if (enqflag) { vecstring = vecstring + "nil"; }else { vecstring = vecstring + std::to_string(x); } vecstring = vecstring + ").rsp at "; vecstring = vecstring + std::to_string(ms2.count()); list.push_back(vecstring); struct BookKeep estr; estr.invtime = ms1; estr.restime = ms2; estr.val = x; estr.nilflag = enqflag; estr.count = i; enqlist.push_back(estr); enqsum += ms2.count() - ms1.count(); usleep(t1); } }
static PyObject * get_rg(Cinvertor *self, PyObject *args) { double *pars; PyObject *data_obj; Py_ssize_t npars; double value; if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; OUTVECTOR(data_obj,pars,npars); value = rg(pars, self->params.d_max, npars, 101); return Py_BuildValue("f", value ); }
int main(int argc, char** argv) { //read the first argument to set the function. if(argc < 3) show_help_short(argv); int randseed=int(time(NULL)); ZRANDOMv3 rg(randseed); int nsample=10000; if(argc>=4) nsample=atoi(argv[3]); ifstream fa(argv[1]); ifstream fb(argv[2]); assert(fa.good()&&fb.good()&&"I can not open the file that contains the partition."); vector <string> pas;//partition a in string vector <string> pbs;//partition b in string string tmpstr; while(fa >> tmpstr) pas.push_back(tmpstr); while(fb >> tmpstr) pbs.push_back(tmpstr); assert(pas.size() == pbs.size() && "Two partitions have different number of nodes !"); vector <int> pa;//partition a in number vector <int> pb;//partition b in number int qa=ps2p(pas,pa); int qb=ps2p(pbs,pb); double the_nmi=0; bool agtb=true; //qa is greater than qb if(qa<qb) agtb=false; if(agtb) the_nmi=compute_nmi(pa,pb); else the_nmi=compute_nmi(pb,pa); double tot_nmi=0; for(int sample=0; sample<nsample; sample++) { double nmi=0; if(agtb) { shuffle_seq(pb,rg); nmi=compute_nmi(pa,pb); } else { shuffle_seq(pa,rg); nmi=compute_nmi(pb,pa); } tot_nmi += nmi; } tot_nmi /= nsample; cout<<the_nmi-tot_nmi<<endl; }
void f() { int i; int &r = i; r = 1; int *p = &r; int &rr = r; int (&rg)(int) = g; rg(i); int a[3]; int (&ra)[3] = a; ra[1] = i; int *Q; int *& P = Q; P[1] = 1; }
void FormulaCreationMenu::create_random_formula(CNFFormula & f) { ask_k(); ask_n(); int p; while(1){ try{ p = ui->getint("What is 1/p? (fraction of the clauses that we use - enter 5 to pick clauses with probability 1/5)"); break; } catch(UserInputException e){ std::cout << e.what() << std::endl; } } RandomSatGenerator rg(n, k, p); rg.generate_formula(f); }
int main(int,char**) { ////////////////////////////////////////////////////////// /// create a .csv file : ///////////////////////////////// ////////////////////////////////////////////////////////// std::ofstream writer("out.csv"); if(writer.fail()) { std::cout << "can't open out.csv." << std::endl; return EXIT_FAILURE; } unsigned int entries = 1000; tools::random::gauss rg(1,2); tools::randf::bw rbw(0,1); ////////////////////////////////////////////////////////// /// create and write a ntuple : ////////////////////////// ////////////////////////////////////////////////////////// //tools::wcsv::ntuple ntu(writer,'\t'); tools::wcsv::ntuple ntu(writer); //default sep is ',' // create some columns with basic types : tools::wcsv::ntuple::column<unsigned int>* col_index = ntu.create_column<unsigned int>("index"); tools::wcsv::ntuple::column<double>* col_rgauss = ntu.create_column<double>("rgauss"); tools::wcsv::ntuple::column<float>* col_rbw = ntu.create_column<float>("rbw"); // fill : for(unsigned int count=0;count<entries;count++) { col_index->fill(count); col_rgauss->fill(rg.shoot()); col_rbw->fill(rbw.shoot()); ntu.add_row(); // it will write columns data as a row in the file. } ////////////////////////////////////////////////////////// /// close file : ///////////////////////////////////////// ////////////////////////////////////////////////////////// writer.close(); return EXIT_SUCCESS; }
int main (int argc, const char* argv[] ) { ucam::util::initLogger ( argc, argv ); FORCELINFO ( argv[0] << " starts!" ); ucam::util::RegistryPO rg ( argc, argv ); FORCELINFO ( rg.dump ( "CONFIG parameters:\n=====================", "=====================" ) ) ; std::string semiring = rg.get<std::string> (HifstConstants::kHifstSemiring); if (semiring == HifstConstants::kHifstSemiringStdArc) { run<fst::StdArc> (rg); } else if (semiring == HifstConstants::kHifstSemiringLexStdArc) { run<fst::LexStdArc> (rg); } else if (semiring == HifstConstants::kHifstSemiringTupleArc) { run<TupleArc32> (rg); } else { LERROR ("Sorry, semiring option not correctly defined"); } FORCELINFO ( argv[0] << " ends!" ); }
void DblqhProxy::sendEXEC_SR_2(Signal* signal, Uint32 ssId) { Ss_EXEC_SR_2& ss = ssFind<Ss_EXEC_SR_2>(ssId); if (!lastReply(ss)) { jam(); return; } NodeBitmask nodes; nodes.assign(NdbNodeBitmask::Size, ss.m_sig.sr_nodes); NodeReceiverGroup rg(DBLQH, nodes); signal->theData[0] = ss.m_sig.nodeId; sendSignal(rg, ss.m_gsn, signal, 1, JBB); ssRelease<Ss_EXEC_SR_2>(ssId); }
void recession(const Graph &g, vector<int> &res) { assert(g.size() == res.size()); int n = g.size(); vector<vector<int>> rg(n); for (int i = 0; i < n; ++i) for (auto e: g[i]) rg[e.dest].push_back(i); vector<int> cnt(n); REP(i,n) cnt[i] = g[i].size(); queue<int> que; REP(i,n) if (cnt[i] == 0) que.push(i); while (!que.empty()) { int v = que.front(); que.pop(); int c = update(g, res, v); for (int i: rg[v]) { if (res[i] != 0) continue; if (cnt[i] <= 0) continue; cnt[i] -= c; if (cnt[i] <= 0) que.push(i); } } }
int main() { int32 seed = time(0); // random seed // choose one of the random number generators: TRandomMersenne rg(seed); // make instance of random number generator // or: // TRanrotWGenerator rg(seed); // make instance of random number generator // or: // TRandomMotherOfAll rg(seed); // make instance of random number generator int i; // loop counter double r; // random number int32 ir; // random integer number // make random integers in interval from 0 to 99, inclusive: printf("\n\nRandom integers in interval from 0 to 99:\n"); for (i=0; i<40; i++) { ir = rg.IRandom(0,99); printf ("%6li ", ir); } // make random floating point numbers in interval from 0 to 1: printf("\n\nRandom floating point numbers in interval from 0 to 1:\n"); for (i=0; i<32; i++) { r = rg.Random(); printf ("%8.6f ", r); } // make random bits (Not for TRandomMotherOfAll): printf("\n\nRandom bits (hexadecimal):\n"); for (i=0; i<32; i++) { ir = rg.BRandom(); printf ("%08lX ", ir); } EndOfProgram(); // system-specific exit code return 0; }
void KWidget::setBackgroundGradient( const QtGradient& gd ) { Q_D(KWidget); QBrush brush; switch(gd.t) { case QGradient::LinearGradient: { QLinearGradient lg(gd.d.l.startx, gd.d.l.starty, gd.d.l.finalx, gd.d.l.finaly); lg.setCoordinateMode(QGradient::ObjectBoundingMode); lg.setSpread(gd.spread); lg.setStops(gd.gs); brush = QBrush(lg); } break; case QGradient::ConicalGradient: { QConicalGradient cg(gd.d.c.centerx, gd.d.c.centery,gd.d.c.angle); cg.setCoordinateMode(QGradient::ObjectBoundingMode); cg.setSpread(gd.spread); cg.setStops(gd.gs); brush = QBrush(cg); } break; case QGradient::RadialGradient: { QRadialGradient rg(gd.d.r.centerx, gd.d.r.centery,gd.d.r.radius); rg.setCoordinateMode(QGradient::ObjectBoundingMode); rg.setSpread(gd.spread); rg.setStops(gd.gs); brush = QBrush(rg); } break; } if(d->backgroundBrush == brush) return; d->backgroundBrush = brush; updateBackgroundBrush(); }
void create_ic(Particle *p, int npart){ int npoints = 1000; double *kk, *pofk; // Read in and store P(k,z=0) kk = new double[npoints]; pofk = new double[npoints]; ifstream fp("pofk.txt"); for(int i = 0;i < npoints; i++){ fp >> kk[i]; fp >> pofk[i]; } DSpline pofk_spline = DSpline(kk, pofk, npoints, "P(k) spline"); // Integrate growth-factor // ... not implemented // Generate random numbers random_device rd; int seed = rd(); mt19937 rg(seed); uniform_real_distribution<double> unidist(0, 1); int nrandom = npart * 3 * 2; double *randoms = new double[nrandom]; for(int i = 0; i < nrandom; i++){ randoms[i] = unidist(rg); } // Make realisation in Fourier space // ... not implemented // FFT back to get displacement field // ... not implemented // Assign particles and move them // ... not implemented delete[] randoms; }
static Boolean qt_mac_nav_filter(AEDesc *theItem, void *info, void *myd, NavFilterModes) { qt_mac_nav_filter_type *t = (qt_mac_nav_filter_type *)myd; if(!t || !t->filts || t->index >= t->filts->count()) return true; NavFileOrFolderInfo *theInfo = (NavFileOrFolderInfo *)info; QString file; qt_mac_filter_name *fn = t->filts->at(t->index); if(!fn) return true; if(theItem->descriptorType == typeFSRef) { FSRef ref; AEGetDescData(theItem, &ref, sizeof(ref)); if(!str_buffer) { qAddPostRoutine(cleanup_str_buffer); str_buffer = (UInt8 *)malloc(1024); } FSRefMakePath(&ref, str_buffer, 1024); file = QString::fromUtf8((const char *)str_buffer); int slsh = file.lastIndexOf(QLatin1Char('/')); if(slsh != -1) file = file.right(file.length() - slsh - 1); } QStringList reg = fn->regxp.split(QLatin1String(";")); for(QStringList::Iterator it = reg.begin(); it != reg.end(); ++it) { QRegExp rg((*it), false, true); #ifdef DEBUG_FILEDIALOG_FILTERS qDebug("Q3FileDialog:%d, asked to filter.. %s (%s)", __LINE__, file.latin1(), (*it).latin1()); #endif if(rg.exactMatch(file)) return true; } return (theInfo->isFolder && !file.endsWith(QLatin1String(".app"))); }
void test::tb() { sc_biguint<128> aes_key_var, aes_data_var; bool decrypt_var; scv_random::set_global_seed(53246); random_generator rg("random_generator"); transactor->resetea(); while (1) { rg.aes_key->next(); rg.aes_data->next(); rg.decrypt->next(); aes_data_var = *(rg.aes_data); aes_key_var = *(rg.aes_key); decrypt_var = *(rg.decrypt); if (!decrypt_var) { //cout << "Encrypt: 0x" << (int)des_data_var.range(63,32) << (int)des_data_var.range(31,0) << " 0x" << (int)des_key_var.range(63,32) << (int)des_key_var.range(31,0) << " " << sc_time_stamp() << endl; transactor->encrypt(aes_data_var, aes_key_var); } else { //cout << "Decrypt: 0x" << (int)des_data_var.range(63,32) << (int)des_data_var.range(31,0) << " 0x" << (int)des_key_var.range(63,32) << (int)des_key_var.range(31,0) << " " << sc_time_stamp() << endl; transactor->decrypt(aes_data_var, aes_key_var); } } }