/***********************************************************************//** * @brief Returns model energy flux between [emin, emax] (units: erg/cm2/s) * * @param[in] emin Minimum photon energy. * @param[in] emax Maximum photon energy. * @return Energy flux (erg/cm2/s). * * Computes * * \f[ * \int_{\tt emin}^{\tt emax} S_{\rm E}(E | t) E \, dE * \f] * * where * - [@p emin, @p emax] is an energy interval, and * - \f$S_{\rm E}(E | t)\f$ is the spectral model (ph/cm2/s/MeV). * The integration is done numerically. ***************************************************************************/ double GModelSpectralSmoothBrokenPlaw::eflux(const GEnergy& emin, const GEnergy& emax) const { // Initialise flux double eflux = 0.0; // Compute only if integration range is valid if (emin < emax) { // Initialise function to integrate eflux_kern kernel(prefactor(), index1(), pivot(), index2(), breakenergy(), beta()); // Initialise integral class with function GIntegral integral(&kernel); // Set integration precision integral.eps(1.0e-8); // Calculate integral between emin and emax eflux = integral.romberg(emin.MeV(), emax.MeV()); // Convert from MeV/cm2/s to erg/cm2/s eflux *= gammalib::MeV2erg; } // endif: integration range was valid // Return flux return eflux; }
static void tst1(unsigned n1) { typedef fvi<data, to_feature_vector, data_hash> data_set; data_set index1(NUM_FEATURES, to_feature_vector(NUM_FEATURES)); ptr_vector<data> index2; for (unsigned i = 0; i < n1; i++) { int op = rand()%6; if (op < 3) { data * d = mk_random_data(); if (!index1.contains(d)) { // TRACE("fvi", tout << "inserting: " << *d << "\n";); index1.insert(d); index2.push_back(d); SASSERT(std::find(index2.begin(), index2.end(), d) != index2.end()); SASSERT(index1.contains(d)); } } else if (op < 4) { if (!index2.empty()) { unsigned idx = rand() % index2.size(); if (index2[idx]) { SASSERT(index1.contains(index2[idx])); } } } else if (op < 5) { if (!index2.empty()) { unsigned idx = rand() % index2.size(); if (index2[idx]) { // TRACE("fvi", tout << "erasing: " << *(index2[idx]) << "\n";); index1.erase(index2[idx]); SASSERT(!index1.contains(index2[idx])); index2[idx] = 0; } } } else { if (!index2.empty()) { unsigned idx = rand() % index2.size(); data * d = index2[idx]; if (d) index1.visit(d, le_visitor(d)); } } } TRACE("fvi", data_set::statistics s; index1.stats(s); tout << "size: " << s.m_size << "\n"; tout << "num. nodes: " << s.m_num_nodes << "\n"; tout << "num. leaves: " << s.m_num_leaves << "\n"; tout << "min. leaf size: " << s.m_min_leaf_size << "\n"; tout << "max. leaf size: " << s.m_max_leaf_size << "\n"; );
void SqliteTests::initTestCase() { verifyCreateTable(); foreignKey(); DQConnection defaultConnection = DQConnection::defaultConnection(); db = QSqlDatabase::addDatabase("QSQLITE"); db.setDatabaseName( "tests.db" ); QVERIFY( db.open() ); QVERIFY( !defaultConnection.isOpen()); QVERIFY (connect.open(db) ); QVERIFY(defaultConnection.isOpen()); // connect become default connection DQSql sql = connect.sql(); QVERIFY( sql.createTableIfNotExists<Model1>() ); QVERIFY( sql.exists(dqMetaInfo<Model1>() ) ); QVERIFY( sql.dropTable(dqMetaInfo<Model1>()) ); QVERIFY( !sql.exists(dqMetaInfo<Model1>() ) ); QVERIFY( sql.createTableIfNotExists<Model1>() ); QVERIFY ( connect.addModel<Model1>() ); QVERIFY ( connect.addModel<Model2>() ); QVERIFY (!connect.addModel<Model1>() ); QVERIFY (!connect.addModel<Model3>() ); QVERIFY ( connect.addModel<Model4>() ); QVERIFY ( connect.addModel<User>() ); QVERIFY ( connect.addModel<Config>() ); QVERIFY ( connect.addModel<ExamResult>() ); QVERIFY ( connect.addModel<AllType>() ); QVERIFY ( connect.addModel<HealthCheck>()); QVERIFY( connect.dropTables() ); QVERIFY( connect.createTables() ); // recreate table /* Create index */ DQIndex<Model1> index1("index1"); index1 << "key" << "value"; QVERIFY(connect.createIndex(index1)); // drop the index QVERIFY(connect.dropIndex(index1.name())); }
void index1(int i, int f) { struct item* p; int j, k; if (i >= idx.rank) { switch (f) { case 0: p = sp[-2]; p->index = access(); putdat(sp[-1], getdat(p)); return; case 1: datum = getdat(sp[-idx.rank - 3]); case 2: p = ((SymTabEntry*)sp[-2])->itemp; p->index = access(); putdat(p, datum); return; } } p = sp[-i - 3]; if (p->itemType == EL) { for (j = 0; j < idx.dim[i]; j++) { idx.idx[i] = j; index1(i + 1, f); } return; } p->index = 0; for (j = 0; j < p->size; j++) { k = fix(getdat(p)) - iorigin; if (k < 0 || k >= idx.dim[i]) error(ERR_index, ""); idx.idx[i] = k; index1(i + 1, f); } }
index1(i, f) { struct item *p; int j, k; if(i >= idx.rank) { switch(f) { case 0: p = sp[-2]; p->index = access_(); putdat(sp[-1], getdat(p)); return; case 1: datum = getdat(sp[-idx.rank-3]); case 2: p = ((struct nlist *)sp[-2])->itemp; p->index = access_(); putdat(p, datum); return; } } p = sp[-i-3]; if(p->type == EL) { for(j=0; j<idx.dim[i]; j++) { idx.idx[i] = j; index1(i+1, f); } return; } p->index = 0; for(j=0; j<p->size; j++) { k = fix(getdat(p)) - thread.iorg; if(k < 0 || k >= idx.dim[i]) error("subscript X"); idx.idx[i] = k; index1(i+1, f); } }
/*** Parse a slice/select assign statement ***/ Node* Parser::parseSliceSelectAssign() { if(!hasTokens() || peekToken().getType() != T_IDENTIFIER) throw ParserSyntaxException(getToken(), "Expected variable identifier!"); // Store the variable std::auto_ptr<Variable> target(new Variable(getToken())); if(!hasTokens() || peekToken().getType() != T_LBRACKET) throw ParserSyntaxException(getToken(), "Expected '['!"); Token tok = getToken(); std::auto_ptr<Object> index1(parseExpression()); if(hasTokens() && peekToken().getType() == T_RBRACKET) { getToken(); if(!hasTokens() || peekToken().getType() != T_ASSIGN) throw ParserSyntaxException(getToken(), "Expected ':='!"); getToken(); std::auto_ptr<Object> expr(parseExpression()); SelectAssign* result = new SelectAssign(target.release(), index1.release(), expr.release()); result->setLineNumber(tok.getLineNumber()); result->setColumnNumber(tok.getColumnNumber()); return result; } if(!hasTokens() || peekToken().getType() != T_COLON) throw ParserSyntaxException(getToken(), "Expected ':' or ']'!"); getToken(); std::auto_ptr<Object> index2(parseExpression()); if(!hasTokens() || peekToken().getType() != T_RBRACKET) throw ParserSyntaxException(getToken(), "Expected ']'!"); getToken(); if(!hasTokens() || peekToken().getType() != T_ASSIGN) throw ParserSyntaxException(getToken(), "Expected ':='!"); getToken(); std::auto_ptr<Object> expr(parseExpression()); SliceAssign* result = new SliceAssign(target.release(), index1.release(), index2.release(), expr.release()); result->setLineNumber(tok.getLineNumber()); result->setColumnNumber(tok.getColumnNumber()); return result; }
/***********************************************************************//** * @brief Update Monte Carlo pre computation cache * * Updates the precomputation cache for Monte Carlo simulations. ***************************************************************************/ void GModelSpectralSmoothBrokenPlaw::update_mc_cache(void) const { // Check if we need to update the cache if (prefactor() != m_mc_prefactor || index1() != m_mc_index1 || index2() != m_mc_index2 || pivot().MeV() != m_mc_pivot || breakenergy().MeV() != m_mc_breakenergy) { // Set parameters for which Monte Carlo cache was computed m_mc_prefactor = prefactor(); m_mc_index1 = index1(); m_mc_index2 = index2(); m_mc_pivot = pivot().MeV(); m_mc_breakenergy = breakenergy().MeV(); // Compute prefactor at pivot energy double pre = prefactor() * std::pow(breakenergy().MeV()/pivot().MeV(), index1()); // Find out which index is harder. This is important since the smoothly // broken power law follows the hard index below the break energy and // the softer index above the break energy. double index1 = (m_mc_index1 > m_mc_index2) ? m_mc_index1 : m_mc_index2; double index2 = (m_mc_index1 > m_mc_index2) ? m_mc_index2 : m_mc_index1; // Set broken power law for Monte Carlo simulations m_mc_brokenplaw = GModelSpectralBrokenPlaw(pre, index1, breakenergy(), index2); } // endif: Update was required // Return return; }
std::vector<Real> power_spread_note(Date evaluationDate, Real notional, Schedule schedule, DayCounter dayCounter, BusinessDayConvention bdc, std::vector<Real> gearing, std::vector<Real> spread, std::vector<Real> caps, std::vector<Real> floors, bool isAvg, Date firstCallDate, Real pastFixing, boost::shared_ptr<StochasticProcess1D> obs1Process, boost::shared_ptr<StochasticProcess1D> obs2Process, boost::shared_ptr<HullWhiteProcess> discProcess, Real rho12, Real rho1disc, Real rho2disc, Size numSimulation, Size numCalibration) { Date todaysDate = evaluationDate; Settings::instance().evaluationDate() = todaysDate; boost::shared_ptr<IborIndex> index1(new Euribor3M(Handle<YieldTermStructure>( discProcess->yieldTermStructure() ))); boost::shared_ptr<SpreadIndex> index(new SpreadIndex(index1, index1)); boost::shared_ptr<Callability> callability(new Callability(Callability::Price(notional, Callability::Price::Clean), Callability::Call, firstCallDate)); CallabilitySchedule callSchedule; callSchedule.push_back(callability); /***********************************************************************************/ PowerSpreadNote testProduct(0, notional, schedule, index, dayCounter, bdc, Null<Natural>(), gearing, spread, caps, floors, isAvg, 100.0, Date(), callSchedule, Exercise::Bermudan); /*****Pricing Engine*****/ std::vector<boost::shared_ptr<StochasticProcess1D> > pros; pros.push_back(discProcess); pros.push_back(obs1Process); pros.push_back(obs2Process); Matrix corr(3,3,1.0); corr[0][1] = corr[1][0] = rho1disc; corr[0][2] = corr[2][0] = rho2disc; corr[1][2] = corr[2][1] = rho12; boost::shared_ptr<StochasticProcessArray> processes(new StochasticProcessArray(pros, corr)); boost::shared_ptr<PricingEngine> engine_lsmc(new MC_PowerSpread_Engine_LSMC<>(processes, 0.0, //pastAccrual 256, //seed numSimulation, //required samples numCalibration, //calibration samples true, //antithetic false, //control variate false //brownian bridge )); testProduct.setPricingEngine(engine_lsmc); std::vector<Real> rst; rst.push_back(testProduct.NPV()); rst.push_back(testProduct.errorEstimate()); return rst; }
/* TODO - label_contour is called two times; only once suffices */ AnimalExport ImgPUInt32 * msskl_difference(ann_img *aimg) { ImgPUInt32 *imcont, *immsskel, *imseed, *imperim; puint32 *seed, *cont, *perim, *pred, *label, *msskel, maxd1, maxd2, MaxD; int r,c,i,j,k,qx,qy,p,q, d1,d2, *idxlut,n; r = aimg->label->rows; c = aimg->label->cols; n = r*c; idxlut = aimg->label->lut; imcont = label_contour(aimg->img); imperim = perimeter(aimg->img); immsskel = new_img_puint32(r,c); imseed = root_map(aimg->pred); seed = imseed->data; cont = imcont->data; perim = imperim->data; msskel = immsskel->data; pred = aimg->pred->data; label = aimg->label->data; MaxD = 0; for (i=0; i<r; i++) for (j=0; j<c; j++) { p = index1(i,j,idxlut); // @@@ why eliminate the contours?? if (pred[p] != (unsigned)p) {/* Eliminates the contours and considers the side option */ maxd1 = maxd2 = 0; for (k=0; k < 4; k++) { qy = n4[k][0] + i; qx = n4[k][1] + j; if (valid_pixel(r,c,qx,qy)) { q = index1(qy,qx,idxlut); if (cont[seed[p]] == cont[seed[q]]) { // not a SKIZ d2 = label[q] - label[p]; if (d2 > (int)perim[seed[p]]-d2) d2 = (int)perim[seed[p]]-d2; if (d2 > (int)maxd2) maxd2 = (unsigned)d2; } else { // a SKIZ d1 = cont[seed[q]] - cont[seed[p]]; if (d1 > (int)maxd1) maxd1 = (unsigned)d1; } } } if (maxd1 > 0) msskel[p] = UINT_MAX; else { msskel[p] = maxd2; if (msskel[p] > MaxD) MaxD = msskel[p]; } } } for (p=0; p < n; p++) if (msskel[p] == UINT_MAX) msskel[p] = MaxD + 1; imfree_puint32(&imcont); imfree_puint32(&imperim); imfree_puint32(&imseed); return immsskel; }
ex_index() { struct item *p, *q; int i, j, f, n, lv; n = *pcp++; f = *pcp; p = sp[-1]; if(f == ASGN) { pcp++; if(p->type != LV) error("indexed assign value"); if(((struct nlist *)p)->use != DA) fetch1(); /* error("used before set"); */ q = ((struct nlist *)p)->itemp; } else q = fetch1(); if(q->rank != n) error("subscript C"); idx.rank = 0; for(i=0; i<n; i++) { p = sp[-i-2]; if(p->type == EL) { idx.dim[idx.rank++] = q->dim[i]; continue; } p = fetch(p); sp[-i-2] = p; for(j=0; j<p->rank; j++) idx.dim[idx.rank++] = p->dim[j]; } size(); if(f == ASGN) { p = fetch(sp[-n-2]); sp[-n-2] = p; if (p->size > 1) { if(idx.size != p->size) error("assign C"); f = 1; /* v[i] <- v */ } else { if (idx.size && !p->size) error("assign C"); /* Note -- for idx.size = 0, no assign occurs * anyway, so it is safe to set "datum" to 0 */ datum = p->size ? getdat(p) : 0; f = 2; /* v[i] <- s */ } ex_elid(); } else { p = newdat(q->type, idx.rank, idx.size); copy(IN, idx.dim, p->dim, idx.rank); *sp++ = p; f = 0; /* v[i] */ } bidx(q); index1(0, f); if(f == 0) { p = sp[-1]; sp--; for(i=0; i<=n; i++) pop(); *sp++ = p; } else { pop(); /* pop ELID */ sp--; /* skip over LV */ for(i=0; i<n; i++) pop(); } }
void ex_index() { struct item *p, *q; int i, j, f, n; n = *gsip->ptr++; f = *gsip->ptr; p = sp[-1]; if (f == ASGN) { gsip->ptr++; if (p->itemType != LV) error(ERR_value, "not a local variable"); if (((SymTabEntry*)p)->entryUse != DA) fetch1(); q = ((SymTabEntry*)p)->itemp; } else q = fetch1(); if (q->rank != n) error(ERR_index, ""); idx.rank = 0; for (i = 0; i < n; i++) { p = sp[-i - 2]; if (p->itemType == EL) { idx.dim[idx.rank++] = q->dim[i]; continue; } p = fetch(p); sp[-i - 2] = p; for (j = 0; j < p->rank; j++) idx.dim[idx.rank++] = p->dim[j]; } size(); if (f == ASGN) { p = fetch(sp[-n - 2]); sp[-n - 2] = p; if (p->size > 1) { if (idx.size != p->size) error(ERR_length, ""); f = 1; /* v[i] <- v */ } else { if (idx.size && !p->size) error(ERR_length, ""); /* Note -- for idx.size = 0, no assign occurs * anyway, so it is safe to set "datum" to 0 */ datum = p->size ? getdat(p) : 0; f = 2; /* v[i] <- s */ } ex_elid(); } else { p = newdat(q->itemType, idx.rank, idx.size); copy(IN, (char*)idx.dim, (char*)p->dim, idx.rank); *sp++ = p; f = 0; /* v[i] */ } bidx(q); index1(0, f); if (f == 0) { p = sp[-1]; sp--; for (i = 0; i <= n; i++) pop(); *sp++ = p; } else { pop(); /* pop ELID */ sp--; /* skip over LV */ for (i = 0; i < n; i++) pop(); } }
std::vector<Real> power_spread_swap(Date evaluationDate, Real notional, PowerSpreadSwap::Side side, Rate alpha, Schedule floatingSchedule, Schedule fixedSchedule, DayCounter dayCounter, BusinessDayConvention bdc, std::vector<Real> gearing, std::vector<Real> spread, std::vector<Real> caps, std::vector<Real> floors, bool isAvg, Date firstCallDate, Real pastFixing, Rate floatingFixingRate, Real floatingGearing, DayCounter floatingDayCounter, boost::shared_ptr<StochasticProcess1D> obs1Process, boost::shared_ptr<StochasticProcess1D> obs2Process, YieldCurveParams disc, Real rho12, Real rho1disc, Real rho2disc, Size numSimulation, Size numCalibration) { Date todaysDate = evaluationDate; Settings::instance().evaluationDate() = todaysDate; boost::shared_ptr<IborIndex> index1(new Euribor3M(Handle<YieldTermStructure>( disc.yts ))); boost::shared_ptr<SpreadIndex> index(new SpreadIndex(index1, index1)); boost::shared_ptr<Callability> callability(new Callability(Callability::Price(notional, Callability::Price::Clean), Callability::Call, firstCallDate)); CallabilitySchedule callSchedule; callSchedule.push_back(callability); boost::shared_ptr<StochasticProcess1D> discProcess(new HullWhiteProcess(Handle<YieldTermStructure>(disc.yts), disc.hwParams.a, disc.hwParams.sigma)); /***********************************************************************************/ Leg floatingcashflows = IborLeg(floatingSchedule, index1) .withNotionals(notional) .withPaymentDayCounter(floatingDayCounter) .withPaymentAdjustment(bdc) .withSpreads(alpha) .withGearings(floatingGearing) .withPaymentAdjustment(bdc); PowerSpreadSwap testProduct(0, notional, side, floatingSchedule, floatingcashflows, alpha, fixedSchedule, index, dayCounter, bdc, Null<Natural>(), gearing, spread, caps, floors, isAvg, 100.0, Date(), callSchedule, Exercise::Bermudan); /*****Pricing Engine*****/ std::vector<boost::shared_ptr<StochasticProcess1D> > pros; pros.push_back(discProcess); pros.push_back(obs1Process); pros.push_back(obs2Process); Matrix corr(3,3,1.0); corr[0][1] = corr[1][0] = rho1disc; corr[0][2] = corr[2][0] = rho2disc; corr[1][2] = corr[2][1] = rho12; boost::shared_ptr<StochasticProcessArray> processes(new StochasticProcessArray(pros, corr)); boost::shared_ptr<PricingEngine> engine_lsmc(new MC_PowerSpread_Swap_Engine_LSMC<>(processes, 0.03, //pastFixing 0.03, 256, //seed numSimulation, //required samples numCalibration, //calibration samples true, //antithetic false, //control variate false //brownian bridge )); testProduct.setPricingEngine(engine_lsmc); std::vector<Real> rst; rst.push_back(testProduct.NPV()); rst.push_back(testProduct.errorEstimate()); return rst; }