void mdeath::ratking(monster *z) { g->u.remove_effect("rat"); if (g->u_see(z)) { add_msg(m_warning, _("Rats suddenly swarm into view.")); } std::vector <point> ratspots; int ratx, raty; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { ratx = z->posx() + i; raty = z->posy() + j; if (g->is_empty(ratx, raty)) { ratspots.push_back(point(ratx, raty)); } } } monster rat(GetMType("mon_sewer_rat")); for (int rats = 0; rats < 7 && !ratspots.empty(); rats++) { int rn = rng(0, ratspots.size() - 1); point rp = ratspots[rn]; ratspots.erase(ratspots.begin() + rn); rat.spawn(rp.x, rp.y); g->add_zombie(rat); } }
void mdeath::ratking(monster *z) { g->u.rem_disease("rat"); if (g->u_see(z)) { add_msg(m_warning, _("Rats suddenly swarm into view.")); } std::vector <point> ratspots; int ratx, raty; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { ratx = z->posx() + i; raty = z->posy() + i; if (g->m.move_cost(ratx, raty) > 0 && g->mon_at(ratx, raty) == -1 && !(g->u.posx == ratx && g->u.posy == raty)) { ratspots.push_back(point(ratx, raty)); } } } int rn; monster rat(GetMType("mon_sewer_rat")); for (int rats = 0; rats < 7 && !ratspots.empty(); rats++) { rn = rng(0, ratspots.size() - 1); rat.spawn(ratspots[rn].x, ratspots[rn].y); g->add_zombie(rat); ratspots.erase(ratspots.begin() + rn); } }
void mdeath::ratking(game *g, monster *z) { g->u.rem_disease("rat"); if (g->u_see(z)) { g->add_msg(_("Rats swarm from nowhere to avenge the %s."), z->name().c_str()); } std::vector <point> ratspots; int ratx, raty; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { ratx = z->posx() + i; raty = z->posy() + i; if (g->m.move_cost(ratx, raty) > 0 && g->mon_at(ratx, raty) == -1 && !(g->u.posx == ratx && g->u.posy == raty)) { ratspots.push_back(point(ratx, raty)); } } } int rn; monster rat(g->mtypes[mon_sewer_rat]); for (int rats = 0; rats < 7 && ratspots.size() > 0; rats++) { rn = rng(0, ratspots.size() - 1); rat.spawn(ratspots[rn].x, ratspots[rn].y); g->add_zombie(rat); ratspots.erase(ratspots.begin() + rn); } }
/* * Transform all methods using the information about constant method arguments * that analyze() obtained. */ void PassImpl::optimize(const Scope& scope, const FixpointIterator& fp_iter) { using Data = std::nullptr_t; m_transform_stats = walk::parallel::reduce_methods<Data, Transform::Stats>( scope, [&](Data&, DexMethod* method) { if (method->get_code() == nullptr) { return Transform::Stats(); } auto& code = *method->get_code(); auto intra_cp = fp_iter.get_intraprocedural_analysis(method); if (m_config.create_runtime_asserts) { RuntimeAssertTransform rat(m_config.runtime_assert); rat.apply(*intra_cp, fp_iter.get_whole_program_state(), method); return Transform::Stats(); } else { Transform tf(m_config.transform); return tf.apply(*intra_cp, fp_iter.get_whole_program_state(), &code); } }, [](Transform::Stats a, Transform::Stats b) { // reducer return a + b; }, [&](unsigned int) { // data initializer return nullptr; }); }
Monomial LCM(Monomial a, Monomial b) { Rational rat(1, 1); Monomial c(rat, a.powers); for (int i = 0; i < size; i++) { if (a.powers[i] < b.powers[i]) c.powers[i] = b.powers[i]; } return c;//Return the new monomial }
int main() { boost::rational<int> rat(2); rat -= 0.5; }
void DumpModel::dump(Amr* parent, int force_dump) { // Exit if it isn't the right time to do the dump if (force_dump == 0 && parent->levelSteps(0) % interval != 0) { return; } // Create flattened list of ordered, disjoint boxes from the grid hierarchy list<Box> bxlist; list<int> lnlist; vector<int> rat(parent->finestLevel(), 1); for (int ln = 0; ln <= parent->finestLevel(); ln++) { // rat[lnp] will be ratio between levels lnp and ln if (ln > 0) { for (int lnp = 0; lnp < ln; lnp++) { rat[lnp] *= parent->refRatio(ln - 1)[0]; } } // Insert grids of level ln into list, trimming coarser grids as needed const BoxArray& grids = parent->boxArray(ln); for (int igr = 0; igr < grids.size(); igr++) { const Box& reg = grids[igr]; list<Box>::iterator bi = bxlist.begin(); list<int>::iterator li = lnlist.begin(); for ( ; bi != bxlist.end(); ) { if (*li == ln) { if (bi->smallEnd(0) > reg.bigEnd(0)) { // Insert reg before bi and break bxlist.insert(bi, reg); lnlist.insert(li, ln); break; } // Increment and continue loop as reg not inserted yet } else { // *li < ln Box bx(BoxLib::refine(*bi,rat[*li])); if (bx.bigEnd(0) >= reg.smallEnd(0)) { if (bx.smallEnd(0) < reg.smallEnd(0) && bx.bigEnd(0) <= reg.bigEnd(0)) { // Trim overlap with reg from *bi leaving low end of *bi bx.setBig(0, reg.smallEnd(0) - 1); bx.coarsen(rat[*li]); *bi = bx; // Increment and continue loop as reg not inserted yet } else if (bx.smallEnd(0) >= reg.smallEnd(0) && bx.bigEnd(0) <= reg.bigEnd(0)) { // Remove *bi from list as reg covers it completely list<Box>::iterator bt = bi; list<int>::iterator lt = li; ++bi; ++li; bxlist.erase(bt); lnlist.erase(lt); // Continue loop as reg not inserted yet; but bypass // increment at end of loop since we've done it already. continue; } else { // To get this far (bx.bigEnd(0) > reg.bigEnd(0)) must be true if (bx.smallEnd(0) < reg.smallEnd(0)) { // Trim overlap with reg from middle of *bi, extract low frag Box bxx(bx); bxx.setBig(0, reg.smallEnd(0) - 1); bxx.coarsen(rat[*li]); // Insert this low fragment of *bi before remainder of *bi bxlist.insert(bi, bxx); lnlist.insert(li, *li); } if (bx.smallEnd(0) <= reg.bigEnd(0)) { // Trim overlap with reg leaving end high end of *bi bx.setSmall(0, reg.bigEnd(0) + 1); bx.coarsen(rat[*li]); *bi = bx; } // Insert reg before high end of *bi and break bxlist.insert(bi, reg); lnlist.insert(li, ln); break; } } } // Increment and continue loop as reg not inserted yet ++bi; ++li; } // end of loop over bi, li if (bi == bxlist.end()) { // We made it to the end without finding another place to insert reg bxlist.push_back(reg); lnlist.push_back(ln); } } } // bxlist now contains an ordered list of disjoint boxes representing // the exposed portions of all levels of the hierarchy. Each box is // at the resolution of its respective level, and the corresponding // entry of lnlist contains the level number. if (ParallelDescriptor::IOProcessor() && verbose >= 2) { cout << "Printing disjoint box list" << endl; list<Box>::iterator bi = bxlist.begin(); list<int>::iterator li = lnlist.begin(); for ( ; bi != bxlist.end(); ++bi, ++li) { cout << "Level " << *li << ", box " << *bi << endl; } } if (ParallelDescriptor::IOProcessor() && verbose >= 1) { cout << "Creating modelDump" << endl; } ofstream dumpfile; if (ParallelDescriptor::IOProcessor()) { dumpfile.open("modelDump", std::ios::out); } const int bufsiz = 200; // must hold 9 fields of width 16 plus a little more char buf[bufsiz]; // The following are not parallel loops. // We are doing the Fab copy portion on all processors because // all must participate, but the write is done only on IOProcessor. int k = 1; list<Box>::iterator bi = bxlist.begin(); list<int>::iterator li = lnlist.begin(); for ( ; bi != bxlist.end(); ++bi, ++li) { const Box& reg = *bi; int ln = *li; Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln)); MultiFab& S_new = castro->get_new_data(State_Type); Fab stmp(reg, S_new.nComp()); S_new.copy(stmp); if (ParallelDescriptor::IOProcessor()) { for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) { IntVect p(i); // Quantities written as 0.0 are not currently used, so we // don't bother to derive them. sprintf(buf, "%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E %d\n", parent->Geom(ln).CellCenter(i, 0), // radius stmp(p, Density), // density stmp(p, Xmom) / stmp(p, Density), // velocity 0.0, // pressure stmp(p, Temp), // temperature (MeV ?) stmp(p, Eint) / stmp(p, Density), // internal energy e 0.0, // entropy 0.0, // cumulative mass stmp(p, FirstAux / stmp(p, Density), // Ye k++); std::string Buf = buf; dumpfile << Buf; } } } if (ParallelDescriptor::IOProcessor()) { dumpfile << Radiation::nGroups << '\n'; } k = 1; bi = bxlist.begin(); li = lnlist.begin(); for ( ; bi != bxlist.end(); ++bi, ++li) { const Box& reg = *bi; int ln = *li; Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln)); MultiFab& R_new = castro->get_new_data(Rad_Type); Fab rtmp(reg, R_new.nComp()); R_new.copy(rtmp); if (ParallelDescriptor::IOProcessor()) { for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) { IntVect p(i); char* bufp = buf; for (int j = 0; ; j++) { sprintf(bufp, "%16.8E", rtmp(p, j)); bufp += 16; if (j + 1 == Radiation::nGroups) { sprintf(bufp, " %d\n", k++); std::string Buf = buf; dumpfile << Buf; break; } else if (j % 4 == 3) { sprintf(bufp, "\n"); std::string Buf = buf; dumpfile << Buf; bufp = buf; } } } } } if (ParallelDescriptor::IOProcessor()) { dumpfile.close(); } }
int main() { boost::rational<int> rat(2); rat = rat + 0.5; }
int main() { boost::rational<int> rat(3.14); }
Constante* Analyseur::ToConstante(QString s) const { Historique* h =Historique::GetInstance(); if (EstConstante(s)) { if (!(h->ModeComplexe()))//Dans ce cas, il ne faut pas utiliser les complexes { if (EstExpression(s)) { /* Il faut retirer les '*/ s=s.left(s.length()-1); s=s.right(s.length()-1); return new Expression(s); } if (EstComplexe(s)) { Reel temp(0); Reel temp2(0); QStringList list=s.split("$", QString::SkipEmptyParts); if (EstRationnel(list[0])) { QStringList tempList=list[0].split("/", QString::SkipEmptyParts); Rationnel rat(tempList[0].toInt(),tempList[1].toInt()); temp=Reel(rat); } else { temp=Reel(VirguleToPoint(list[0]).toDouble()); } if (EstRationnel(list[1])) { QStringList tempList2=list[1].split("/", QString::SkipEmptyParts); Rationnel rat(tempList2[0].toInt(),tempList2[1].toInt()); temp2=Reel(rat); } else { temp2=Reel(VirguleToPoint(list[1]).toDouble()); } return new Complexe(temp,temp2); } if (EstReel(s)) { return new Reel(VirguleToPoint(s).toDouble()); } if (EstRationnel(s)) { QStringList list=s.split("/", QString::SkipEmptyParts); Entier temp=list[0].toInt(); Entier temp2=list[1].toInt(); return new Rationnel(temp,temp2); } if (EstEntier(s)) { return new Entier(s.toInt()); } } else//Il faut tout couvertir en Complexe!!! { Entier entierNull(0); if (EstExpression(s)) { /* Il faut retirer les '*/ s=s.left(s.length()-1); s=s.right(s.length()-1); return new Expression(s); } if (EstComplexe(s)) { Reel temp(0); Reel temp2(0); QStringList list=s.split("$", QString::SkipEmptyParts); if (EstRationnel(list[0])) { QStringList tempList=list[0].split("/", QString::SkipEmptyParts); Rationnel rat(tempList[0].toInt(),tempList[1].toInt()); temp=Reel(rat); } else { temp=Reel(VirguleToPoint(list[0]).toDouble()); } if (EstRationnel(list[1])) { QStringList tempList2=list[1].split("/", QString::SkipEmptyParts); Rationnel rat(tempList2[0].toInt(),tempList2[1].toInt()); temp2=Reel(rat); } else { temp2=Reel(VirguleToPoint(list[1]).toDouble()); } return new Complexe(temp,temp2); } if (EstReel(s)) { return new Complexe(Reel(VirguleToPoint(s).toDouble()),entierNull); } if (EstRationnel(s)) { QStringList list=s.split("/", QString::SkipEmptyParts); Entier temp=list[0].toInt(); Entier temp2=list[1].toInt(); return new Complexe(temp/temp2,entierNull); } if (EstEntier(s)) { return new Complexe(Entier(s.toInt()),entierNull); } } } else { throw Exception("Ce n'est pas une instruction !"); } return 0; }