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);
}
}
}
