void SimpleRangeAccrualRateETI::initializeImpl(const TimeGrid& timeGrid, const boost::shared_ptr<YieldTermStructure>& discountCurve, const boost::shared_ptr<PathGeneratorFactory>& pathGenFactory) { referenceCalculation_->initialize(timeGrid,discountCurve,pathGenFactory); this->payoffDateInfo_->initialize(timeGrid,discountCurve,pathGenFactory); this->rangeNum_ = simpleRangeRateList_.size(); this->assetNum_ = pathGenFactory->numAssets(); Date today = Settings::instance().evaluationDate(); DayCounter dayCounter = Actual365Fixed(); double fixingStartTime = dayCounter.yearFraction( today , calculationStartDate_ ); Size fixingStartPosition = timeGrid.closestIndex(fixingStartTime); double fixingEndTime = dayCounter.yearFraction( today , calculationEndDate_ ); Size fixingEndPosition = timeGrid.closestIndex(fixingEndTime); Size fixingSize = fixingEndPosition - fixingStartPosition; this->fixingDatePositions_ = std::valarray<Size>(fixingSize); for ( Size position = 0 ; fixingSize ; position++ ) { fixingDatePositions_[position] = fixingStartPosition + position; } for ( Size rng = 0 ; this->rangeNum_ ; rng++ ) { simpleRangeRateList_[rng]->initialize(timeGrid,discountCurve,pathGenFactory); } }
HestonSLVMCModel::HestonSLVMCModel( const Handle<LocalVolTermStructure>& localVol, const Handle<HestonModel>& hestonModel, const boost::shared_ptr<BrownianGeneratorFactory>& brownianGeneratorFactory, const Date& endDate, Size timeStepsPerYear, Size nBins, Size calibrationPaths, const std::vector<Date>& mandatoryDates) : localVol_(localVol), hestonModel_(hestonModel), brownianGeneratorFactory_(brownianGeneratorFactory), endDate_(endDate), nBins_(nBins), calibrationPaths_(calibrationPaths) { registerWith(localVol_); registerWith(hestonModel_); const DayCounter dc = hestonModel_->process()->riskFreeRate()->dayCounter(); const Date refDate = hestonModel_->process()->riskFreeRate()->referenceDate(); std::vector<Time> gridTimes; gridTimes.reserve(mandatoryDates.size()+1); for (Size i=0; i < mandatoryDates.size(); ++i) { gridTimes.push_back(dc.yearFraction(refDate, mandatoryDates[i])); } gridTimes.push_back(dc.yearFraction(refDate, endDate)); timeGrid_ = boost::make_shared<TimeGrid>(gridTimes.begin(), gridTimes.end(), std::max(Size(2), Size(gridTimes.back()*timeStepsPerYear))); }
DiscretizedCallableFixedRateBond::DiscretizedCallableFixedRateBond( const CallableBond::arguments& args, const Date& referenceDate, const DayCounter& dayCounter) : arguments_(args) { redemptionTime_ = dayCounter.yearFraction(referenceDate, args.redemptionDate); couponTimes_.resize(args.couponDates.size()); for (Size i=0; i<couponTimes_.size(); ++i) couponTimes_[i] = dayCounter.yearFraction(referenceDate, args.couponDates[i]); callabilityTimes_.resize(args.callabilityDates.size()); for (Size i=0; i<callabilityTimes_.size(); ++i) callabilityTimes_[i] = dayCounter.yearFraction(referenceDate, args.callabilityDates[i]); // similar to the tree swaption engine, we collapse similar coupon // and exercise dates to avoid mispricing. Delete if unnecessary. for (Size i=0; i<callabilityTimes_.size(); i++) { Time exerciseTime = callabilityTimes_[i]; for (Size j=0; j<couponTimes_.size(); j++) { if (withinNextWeek(exerciseTime, couponTimes_[j])) couponTimes_[j] = exerciseTime; } } }
void DayCounterTest::testIntraday() { #ifdef QL_HIGH_RESOLUTION_DATE BOOST_TEST_MESSAGE("Testing intraday behavior of day counter ..."); const Date d1(12, February, 2015); const Date d2(14, February, 2015, 12, 34, 17, 1, 230298); const Time tol = 100*QL_EPSILON; const DayCounter dayCounters[] = { ActualActual(), Actual365Fixed(), Actual360() }; for (Size i=0; i < LENGTH(dayCounters); ++i) { const DayCounter dc = dayCounters[i]; const Time expected = ((12*60 + 34)*60 + 17 + 0.231298) * dc.yearFraction(d1, d1+1)/86400 + dc.yearFraction(d1, d1+2); BOOST_CHECK_MESSAGE( std::fabs(dc.yearFraction(d1, d2) - expected) < tol, "can not reproduce result for day counter " << dc.name()); BOOST_CHECK_MESSAGE( std::fabs(dc.yearFraction(d2, d1) + expected) < tol, "can not reproduce result for day counter " << dc.name()); } #endif }
DiscretizedSwaption::DiscretizedSwaption(const Swaption::arguments& args, const Date& referenceDate, const DayCounter& dayCounter) : DiscretizedOption(boost::shared_ptr<DiscretizedAsset>(), args.exercise->type(), std::vector<Time>()), arguments_(args),exerciseIndex_(new std::vector<std::pair<bool, std::pair<Size, Real> > >) { exerciseTimes_.resize(arguments_.exercise->dates().size()); for (Size i=0; i<exerciseTimes_.size(); ++i) exerciseTimes_[i] = dayCounter.yearFraction(referenceDate, arguments_.exercise->date(i)); // Date adjustments can get time vectors out of synch. // Here, we try and collapse similar dates which could cause // a mispricing. for (Size i=0; i<arguments_.exercise->dates().size(); i++) { Date exerciseDate = arguments_.exercise->date(i); for (Size j=0; j<arguments_.fixedPayDates.size(); j++) { if (withinNextWeek(exerciseDate, arguments_.fixedPayDates[j]) // coupons in the future are dealt with below && arguments_.fixedResetDates[j] < referenceDate) arguments_.fixedPayDates[j] = exerciseDate; } for (Size j=0; j<arguments_.fixedResetDates.size(); j++) { if (withinPreviousWeek(exerciseDate, arguments_.fixedResetDates[j])) arguments_.fixedResetDates[j] = exerciseDate; } for (Size j=0; j<arguments_.floatingResetDates.size(); j++) { if (withinPreviousWeek(exerciseDate, arguments_.floatingResetDates[j])) arguments_.floatingResetDates[j] = exerciseDate; } } Time lastFixedPayment = dayCounter.yearFraction(referenceDate, arguments_.fixedPayDates.back()); Time lastFloatingPayment = dayCounter.yearFraction(referenceDate, arguments_.floatingPayDates.back()); lastPayment_ = std::max(lastFixedPayment,lastFloatingPayment); underlying_ = boost::shared_ptr<DiscretizedAsset>( new DiscretizedSwap(arguments_, referenceDate, dayCounter)); underlyingAsSwap_ = boost::dynamic_pointer_cast<DiscretizedSwap>(underlying_); QL_REQUIRE(underlyingAsSwap_ != nullptr, "Underlying must be a DiscreteSwap object."); }
void VarianceGammaEngine::calculate() const { QL_REQUIRE(arguments_.exercise->type() == Exercise::European, "not an European Option"); boost::shared_ptr<StrikedTypePayoff> payoff = boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff); QL_REQUIRE(payoff, "non-striked payoff given"); DiscountFactor dividendDiscount = process_->dividendYield()->discount( arguments_.exercise->lastDate()); DiscountFactor riskFreeDiscount = process_->riskFreeRate()->discount(arguments_.exercise->lastDate()); DayCounter rfdc = process_->riskFreeRate()->dayCounter(); Time t = rfdc.yearFraction(process_->riskFreeRate()->referenceDate(), arguments_.exercise->lastDate()); Integrand f(payoff, process_->x0(), t, riskFreeDiscount, dividendDiscount, process_->sigma(), process_->nu(), process_->theta()); SimpsonIntegral integrator(1e-4, 5000); Real infinity = 15.0 * std::sqrt(process_->nu() * t); results_.value = integrator(f, 0, infinity); }
void SwingOptionTest::testExtOUJumpVanillaEngine() { BOOST_TEST_MESSAGE("Testing finite difference pricer for the Kluge model..."); SavedSettings backup; boost::shared_ptr<ExtOUWithJumpsProcess> jumpProcess = createKlugeProcess(); const Date today = Date::todaysDate(); Settings::instance().evaluationDate() = today; const DayCounter dc = ActualActual(); const Date maturityDate = today + Period(12, Months); const Time maturity = dc.yearFraction(today, maturityDate); const Rate irRate = 0.1; boost::shared_ptr<YieldTermStructure> rTS(flatRate(today, irRate, dc)); boost::shared_ptr<StrikedTypePayoff> payoff( new PlainVanillaPayoff(Option::Call, 30)); boost::shared_ptr<Exercise> exercise(new EuropeanExercise(maturityDate)); boost::shared_ptr<PricingEngine> engine( new FdExtOUJumpVanillaEngine(jumpProcess, rTS, 25, 200, 50)); VanillaOption option(payoff, exercise); option.setPricingEngine(engine); const Real fdNPV = option.NPV(); const Size steps = 100; const Size nrTrails = 200000; TimeGrid grid(maturity, steps); typedef PseudoRandom::rsg_type rsg_type; typedef MultiPathGenerator<rsg_type>::sample_type sample_type; rsg_type rsg = PseudoRandom::make_sequence_generator( jumpProcess->factors()*(grid.size()-1), BigNatural(421)); GeneralStatistics npv; MultiPathGenerator<rsg_type> generator(jumpProcess, grid, rsg, false); for (Size n=0; n < nrTrails; ++n) { sample_type path = generator.next(); const Real x = path.value[0].back(); const Real y = path.value[1].back(); const Real cashflow = (*payoff)(std::exp(x+y)); npv.add(cashflow*rTS->discount(maturity)); } const Real mcNPV = npv.mean(); const Real mcError = npv.errorEstimate(); if ( std::fabs(fdNPV - mcNPV) > 3.0*mcError) { BOOST_ERROR("Failed to reproduce FD and MC prices" << "\n FD NPV: " << fdNPV << "\n MC NPV: " << mcNPV << " +/- " << mcError); } }
Generalized_HullWhite::Generalized_HullWhite(const Handle<YieldTermStructure>& termStructure, std::vector<Date> dates, std::vector<Real> sigma, Real a, Real fxVol, Real fxCorr) : Vasicek(termStructure->forwardRate(0.0, 0.0, Continuous, NoFrequency), a, 0.0, sigma[0], 0.0), a0_(a), TermStructureConsistentModel(termStructure), fxVol_(fxVol), fxCorr_(fxCorr) { a_ = NullParameter(); b_ = NullParameter(); lambda_ = NullParameter(); DayCounter dc = termStructure->dayCounter(); //volperiods_.push_back(0.0); for (Size i=0; i<dates.size()-1; i++) volperiods_.push_back(dc.yearFraction(Settings::instance().evaluationDate(), dates[i])); sigma_ = PiecewiseConstantParameter(volperiods_, PositiveConstraint()); for (Size i=0; i< sigma_.size(); i++) sigma_.setParam(i, sigma[i]); generateArguments(); registerWith(termStructure); }
Rate MultiplicativePriceSeasonality::seasonalityCorrection(Rate rate, const Date& atDate, const DayCounter& dc, const Date& curveBaseDate, const bool isZeroRate) const { // need _two_ corrections in order to get: seasonality = factor[atDate-seasonalityBase] / factor[reference-seasonalityBase] // i.e. for ZERO inflation rates you have the true fixing at the curve base so this factor must be normalized to one // for YoY inflation rates your reference point is the year before Real factorAt = this->seasonalityFactor(atDate); //Getting seasonality correction for either ZC or YoY Rate f; if (isZeroRate) { Rate factorBase = this->seasonalityFactor(curveBaseDate); Real seasonalityAt = factorAt / factorBase; Time timeFromCurveBase = dc.yearFraction(curveBaseDate, atDate); f = std::pow(seasonalityAt, 1/timeFromCurveBase); } else { Rate factor1Ybefore = this->seasonalityFactor(atDate - Period(1,Years)); f = factorAt / factor1Ybefore; } return (rate + 1)*f - 1; }
FdmDividendHandler::FdmDividendHandler( const DividendSchedule& schedule, const boost::shared_ptr<FdmMesher>& mesher, const Date& referenceDate, const DayCounter& dayCounter, Size equityDirection) : x_(mesher->layout()->dim()[equityDirection]), mesher_(mesher), equityDirection_(equityDirection) { dividends_.reserve(schedule.size()); dividendDates_.reserve(schedule.size()); dividendTimes_.reserve(schedule.size()); for (DividendSchedule::const_iterator iter=schedule.begin(); iter!=schedule.end(); ++iter) { dividends_.push_back((*iter)->amount()); dividendDates_.push_back((*iter)->date()); dividendTimes_.push_back( dayCounter.yearFraction(referenceDate,(*iter)->date())); } Array tmp = mesher_->locations(equityDirection); Size spacing = mesher_->layout()->spacing()[equityDirection]; for (Size i = 0; i < x_.size(); ++i) { x_[i] = std::exp(tmp[i*spacing]); } }
FuturesRateHelper::FuturesRateHelper(const Handle<Quote>& price, const Date& immDate, const Date& endDate, const DayCounter& dayCounter, const Handle<Quote>& convAdj) : RateHelper(price), convAdj_(convAdj) { QL_REQUIRE(IMM::isIMMdate(immDate, false), immDate << " is not a valid IMM date"); earliestDate_ = immDate; if (endDate==Date()) { latestDate_ = IMM::nextDate(immDate, false); latestDate_ = IMM::nextDate(latestDate_, false); latestDate_ = IMM::nextDate(latestDate_, false); } else { QL_REQUIRE(endDate>immDate, "end date (" << endDate << ") must be greater than IMM start date (" << immDate << ")"); latestDate_ = endDate; } yearFraction_ = dayCounter.yearFraction(earliestDate_, latestDate_); registerWith(convAdj_); }
FuturesRateHelper::FuturesRateHelper(Real price, const Date& iborStartDate, Natural lengthInMonths, const Calendar& calendar, BusinessDayConvention convention, bool endOfMonth, const DayCounter& dayCounter, Rate convAdj, Futures::Type type) : RateHelper(price), convAdj_(Handle<Quote>(shared_ptr<Quote>(new SimpleQuote(convAdj)))) { switch (type) { case Futures::IMM: QL_REQUIRE(IMM::isIMMdate(iborStartDate, false), iborStartDate << " is not a valid IMM date"); break; case Futures::ASX: QL_REQUIRE(ASX::isASXdate(iborStartDate, false), iborStartDate << " is not a valid ASX date"); break; default: QL_FAIL("unknown futures type (" << Integer(type) << ")"); } earliestDate_ = iborStartDate; latestDate_ = calendar.advance(iborStartDate, lengthInMonths*Months, convention, endOfMonth); yearFraction_ = dayCounter.yearFraction(earliestDate_, latestDate_); }
void ForwardVanillaEngine<Engine>::getOriginalResults() const { DayCounter rfdc = process_->riskFreeRate()->dayCounter(); DayCounter divdc = process_->dividendYield()->dayCounter(); Time resetTime = rfdc.yearFraction( process_->riskFreeRate()->referenceDate(), this->arguments_.resetDate); DiscountFactor discQ = process_->dividendYield()->discount( this->arguments_.resetDate); this->results_.value = discQ * originalResults_->value; // I need the strike derivative here ... if (originalResults_->delta != Null<Real>() && originalResults_->strikeSensitivity != Null<Real>()) { this->results_.delta = discQ * (originalResults_->delta + this->arguments_.moneyness * originalResults_->strikeSensitivity); } this->results_.gamma = 0.0; this->results_.theta = process_->dividendYield()-> zeroRate(this->arguments_.resetDate, divdc, Continuous, NoFrequency) * this->results_.value; if (originalResults_->vega != Null<Real>()) this->results_.vega = discQ * originalResults_->vega; if (originalResults_->rho != Null<Real>()) this->results_.rho = discQ * originalResults_->rho; if (originalResults_->dividendRho != Null<Real>()) { this->results_.dividendRho = - resetTime * this->results_.value + discQ * originalResults_->dividendRho; } }
void DayCounterTest::testOne() { BOOST_MESSAGE("Testing 1/1 day counter..."); Period p[] = { Period(3,Months), Period(6,Months), Period(1,Years) }; Time expected[] = { 1.0, 1.0, 1.0 }; Size n = sizeof(p)/sizeof(Period); // 1 years should be enough Date first(1,January,2004), last(31,December,2004); DayCounter dayCounter = OneDayCounter(); for (Date start = first; start <= last; start++) { for (Size i=0; i<n; i++) { Date end = start + p[i]; Time calculated = dayCounter.yearFraction(start,end); if (std::fabs(calculated-expected[i]) > 1.0e-12) { BOOST_FAIL("from " << start << " to " << end << ":\n" << std::setprecision(12) << " calculated: " << calculated << "\n" << " expected: " << expected[i]); } } } }
void DefaultProbabilityCurveTest::testFlatHazardRate() { BOOST_TEST_MESSAGE("Testing flat hazard rate..."); Real hazardRate = 0.0100; Handle<Quote> hazardRateQuote = Handle<Quote>( boost::shared_ptr<Quote>(new SimpleQuote(hazardRate))); DayCounter dayCounter = Actual360(); Calendar calendar = TARGET(); Size n = 20; double tolerance = 1.0e-10; Date today = Settings::instance().evaluationDate(); Date startDate = today; Date endDate = startDate; FlatHazardRate flatHazardRate(today, hazardRateQuote, dayCounter); for(Size i=0; i<n; i++){ endDate = calendar.advance(endDate, 1, Years); Time t = dayCounter.yearFraction(startDate, endDate); Probability probability = 1.0 - std::exp(-hazardRate * t); Probability computedProbability = flatHazardRate.defaultProbability(t); if (std::fabs(probability - computedProbability) > tolerance) BOOST_ERROR( "Failed to reproduce probability for flat hazard rate\n" << std::setprecision(10) << " calculated probability: " << computedProbability << "\n" << " expected probability: " << probability); } }
CmsSpreadRangeAccrualCoupon::CmsSpreadRangeAccrualCoupon( const Date& paymentDate, Real nominal, const boost::shared_ptr<SwapSpreadIndex>& index, const Date& startDate, // S const Date& endDate, // T Natural fixingDays, const DayCounter& dayCounter, Real gearing, Rate spread, const Date& refPeriodStart, const Date& refPeriodEnd, const boost::shared_ptr<Schedule>& observationsSchedule, Real lowerTrigger, // l Real upperTrigger // u ) : FloatingRateCoupon(paymentDate, nominal, startDate, endDate, fixingDays, index, gearing, spread, refPeriodStart, refPeriodEnd, dayCounter), observationsSchedule_(observationsSchedule), lowerTrigger_(lowerTrigger), upperTrigger_(upperTrigger){ QL_REQUIRE(lowerTrigger_<upperTrigger, "lowerTrigger_>=upperTrigger"); QL_REQUIRE(observationsSchedule_->startDate()==startDate, "incompatible start date"); QL_REQUIRE(observationsSchedule_->endDate()==endDate, "incompatible end date"); observationDates_ = observationsSchedule_->dates(); observationDates_.pop_back(); //remove end date observationDates_.erase(observationDates_.begin()); //remove start date observationsNo_ = observationDates_.size(); const Handle<YieldTermStructure>& rateCurve = index->swapIndex1()->forwardingTermStructure(); Date referenceDate = rateCurve->referenceDate(); startTime_ = dayCounter.yearFraction(referenceDate, startDate); endTime_ = dayCounter.yearFraction(referenceDate, endDate); for(Size i=0;i<observationsNo_;i++) { observationTimes_.push_back( dayCounter.yearFraction(referenceDate, observationDates_[i])); } }
boost::shared_ptr<path_pricer_type> pathPricer() const { Date referenceDate = model_->termStructure()->referenceDate(); DayCounter dayCounter = model_->termStructure()->dayCounter(); Time forwardMeasureTime = dayCounter.yearFraction(referenceDate, arguments_.endDates.back()); return boost::shared_ptr<path_pricer_type>( new detail::HullWhiteCapFloorPricer(arguments_, model_, forwardMeasureTime)); }
TimeGrid timeGrid() const { Date referenceDate = model_->termStructure()->referenceDate(); DayCounter dayCounter = model_->termStructure()->dayCounter(); // only add future fixing times... std::vector<Time> times; for (Size i=0; i<arguments_.fixingDates.size(); i++) { if (arguments_.fixingDates[i] > referenceDate) times.push_back( dayCounter.yearFraction(referenceDate, arguments_.fixingDates[i])); } // ...and maturity. times.push_back( dayCounter.yearFraction(referenceDate, arguments_.endDates.back())); return TimeGrid(times.begin(), times.end()); }
SubPeriodsCoupon::SubPeriodsCoupon( const Date& paymentDate, Real nominal, const boost::shared_ptr<IborIndex>& index, const Date& startDate, const Date& endDate, Natural fixingDays, const DayCounter& dayCounter, Real gearing, Rate couponSpread, Rate rateSpread, const Date& refPeriodStart, const Date& refPeriodEnd) : FloatingRateCoupon(paymentDate, nominal, startDate, endDate, fixingDays, index, gearing, couponSpread, refPeriodStart, refPeriodEnd, dayCounter), rateSpread_(rateSpread) { const Handle<YieldTermStructure>& rateCurve = index->forwardingTermStructure(); const Date& referenceDate = rateCurve->referenceDate(); observationsSchedule_ = boost::shared_ptr<Schedule>(new Schedule(startDate, endDate, index->tenor(), NullCalendar(), Unadjusted, Unadjusted, DateGeneration::Forward, false)); observationDates_ = observationsSchedule_->dates(); observationDates_.pop_back(); //remove end date observations_ = observationDates_.size(); startTime_ = dayCounter.yearFraction(referenceDate, startDate); endTime_ = dayCounter.yearFraction(referenceDate, endDate); for (Size i=0; i<observations_; ++i) { observationTimes_.push_back( dayCounter.yearFraction(referenceDate, observationDates_[i])); } }
void TreeSwaptionEngine::calculate() const { QL_REQUIRE(arguments_.settlementType==Settlement::Physical, "cash-settled swaptions not priced with tree engine"); QL_REQUIRE(!model_.empty(), "no model specified"); Date referenceDate; DayCounter dayCounter; boost::shared_ptr<TermStructureConsistentModel> tsmodel = boost::dynamic_pointer_cast<TermStructureConsistentModel>(*model_); if (tsmodel) { referenceDate = tsmodel->termStructure()->referenceDate(); dayCounter = tsmodel->termStructure()->dayCounter(); } else { referenceDate = termStructure_->referenceDate(); dayCounter = termStructure_->dayCounter(); } boost::shared_ptr<DiscretizedSwaption> swaption(new DiscretizedSwaption(arguments_, referenceDate, dayCounter)); if (additionalResultCalculator_) { additionalResultCalculator_->setupDiscretizedAsset(swaption); } boost::shared_ptr<Lattice> lattice; if (lattice_) { lattice = lattice_; } else { std::vector<Time> times = swaption->mandatoryTimes(); TimeGrid timeGrid(times.begin(), times.end(), timeSteps_); lattice = model_->tree(timeGrid, additionalResultCalculator_); } std::vector<Time> stoppingTimes(arguments_.exercise->dates().size()); for (Size i=0; i<stoppingTimes.size(); ++i) stoppingTimes[i] = dayCounter.yearFraction(referenceDate, arguments_.exercise->date(i)); swaption->initialize(lattice, stoppingTimes.back()); Time nextExercise = *std::find_if(stoppingTimes.begin(), stoppingTimes.end(), std::bind2nd(std::greater_equal<Time>(), 0.0)); swaption->rollback(nextExercise); results_.value = swaption->presentValue(); if (additionalResultCalculator_) { additionalResultCalculator_->calculateAdditionalResults(); results_.additionalResults = additionalResultCalculator_->additionalResults(); } }
FdmAutocallStepCondition::FdmAutocallStepCondition( const Date& exerciseDates, const Date& referenceDate, const DayCounter& dayCounter, const boost::shared_ptr<FdmMesher> & mesher, const boost::shared_ptr<FdmInnerValueCalculator> & calculator, const boost::shared_ptr<AutocallCondition> & condition) : mesher_(mesher), condition_(condition), calculator_(calculator) { exerciseTimes_.reserve(1); exerciseTimes_.push_back(dayCounter.yearFraction(referenceDate, exerciseDates)); }
Time inflationYearFraction(Frequency f, bool indexIsInterpolated, const DayCounter &dayCounter, const Date &d1, const Date &d2) { Time t=0; if (indexIsInterpolated) { // N.B. we do not use linear interpolation between flat // fixing forecasts for forecasts. This avoids awkwardnesses // when bootstrapping the inflation curve. t = dayCounter.yearFraction(d1, d2); } else { // I.e. fixing is constant for the whole inflation period. // Use the value for half way along the period. // But the inflation time is the time between period starts std::pair<Date,Date> limD1 = inflationPeriod(d1, f); std::pair<Date,Date> limD2 = inflationPeriod(d2, f); t = dayCounter.yearFraction(limD1.first, limD2.first); } return t; }
FdmAffineModelTermStructure::FdmAffineModelTermStructure( const Array& r, const Calendar& cal, const DayCounter& dayCounter, const Date& referenceDate, const Date& modelReferenceDate, const boost::shared_ptr<AffineModel>& model) : YieldTermStructure(referenceDate, cal, dayCounter), r_(r), t_(dayCounter.yearFraction(modelReferenceDate, referenceDate)), model_(model) { registerWith(model_); }
GeneralizedHullWhite::GeneralizedHullWhite( const Handle<YieldTermStructure>& yieldtermStructure, const std::vector<Date>& speedstructure, const std::vector<Date>& volstructure, const std::vector<Real>& speed, const std::vector<Real>& vol) : OneFactorModel(2), TermStructureConsistentModel(yieldtermStructure), speedstructure_(speedstructure), volstructure_(volstructure), a_(arguments_[0]), sigma_(arguments_[1]) { DayCounter dc = yieldtermStructure->dayCounter(); speedperiods_.push_back(0.0); for (Size i=0;i<speedstructure.size()-1;i++) speedperiods_.push_back(dc.yearFraction(speedstructure[0], speedstructure[i+1])); a_ = PiecewiseConstantParameter(speedperiods_, PositiveConstraint()); volperiods_.push_back(0.0); for (Size i=0;i<volstructure.size()-1;i++) volperiods_.push_back(dc.yearFraction(volstructure[0], volstructure[i+1])); sigma_ = PiecewiseConstantParameter(volperiods_, PositiveConstraint()); a_.setParam(0,speed[0]); sigma_.setParam(0,vol[0]); for (Size i=1; i< sigma_.size();i++) { sigma_.setParam(i,vol[i-1]); } for (Size i=1; i< a_.size();i++) { a_.setParam(i,speed[i-1]); } registerWith(yieldtermStructure); }
InterestRate IndexFutures::impliedYield(Real underlyingSpotValue, Real forwardValue, Date settlementDate, Compounding comp, DayCounter dayCounter) { Time t = dayCounter.yearFraction(settlementDate,maturityDate_) ; Real compoundingFactor = forwardValue / underlyingSpotValue; //(underlyingSpotValue-spotIncome(incomeDiscountCurve_)) ; return InterestRate::impliedRate(compoundingFactor, dayCounter, comp, Annual, t); }
FuturesRateHelper::FuturesRateHelper(Real price, const Date& iborStartDate, const Date& iborEndDate, const DayCounter& dayCounter, Rate convAdj, Futures::Type type) : RateHelper(price), convAdj_(Handle<Quote>(shared_ptr<Quote>(new SimpleQuote(convAdj)))) { switch (type) { case Futures::IMM: QL_REQUIRE(IMM::isIMMdate(iborStartDate, false), iborStartDate << " is not a valid IMM date"); if (iborEndDate == Date()) { // advance 3 months latestDate_ = IMM::nextDate(iborStartDate, false); latestDate_ = IMM::nextDate(latestDate_, false); latestDate_ = IMM::nextDate(latestDate_, false); } else { QL_REQUIRE(iborEndDate>iborStartDate, "end date (" << iborEndDate << ") must be greater than start date (" << iborStartDate << ")"); latestDate_ = iborEndDate; } break; case Futures::ASX: QL_REQUIRE(ASX::isASXdate(iborStartDate, false), iborStartDate << " is not a valid ASX date"); if (iborEndDate == Date()) { // advance 3 months latestDate_ = ASX::nextDate(iborStartDate, false); latestDate_ = ASX::nextDate(latestDate_, false); latestDate_ = ASX::nextDate(latestDate_, false); } else { QL_REQUIRE(iborEndDate>iborStartDate, "end date (" << iborEndDate << ") must be greater than start date (" << iborStartDate << ")"); latestDate_ = iborEndDate; } break; default: QL_FAIL("unknown futures type (" << Integer(type) << ")"); } earliestDate_ = iborStartDate; yearFraction_ = dayCounter.yearFraction(earliestDate_, latestDate_); }
/*! The resulting rate is calculated taking the required day-counting rule into account. */ InterestRate equivalentRate(const DayCounter& resultDC, Compounding comp, Frequency freq, Date d1, Date d2, const Date& refStart = Date(), const Date& refEnd = Date()) const { QL_REQUIRE(d2>=d1, "d1 (" << d1 << ") " "later than d2 (" << d2 << ")"); Time t1 = dc_.yearFraction(d1, d2, refStart, refEnd); Time t2 = resultDC.yearFraction(d1, d2, refStart, refEnd); return impliedRate(compoundFactor(t1), resultDC, comp, freq, t2); }
/*! The resulting rate is calculated taking the required day-counting rule into account. */ static InterestRate impliedRate(Real compound, const DayCounter& resultDC, Compounding comp, Frequency freq, const Date& d1, const Date& d2, const Date& refStart = Date(), const Date& refEnd = Date()) { QL_REQUIRE(d2>=d1, "d1 (" << d1 << ") " "later than d2 (" << d2 << ")"); Time t = resultDC.yearFraction(d1, d2, refStart, refEnd); return impliedRate(compound, resultDC, comp, freq, t); }
MCVanillaSwapUCVAEngine::MCVanillaSwapUCVAEngine( const Calendar &calender, const DayCounter &dayCounter, Date referenceDate, const Handle<YieldTermStructure> &riskFreeTermStructure, const boost::shared_ptr<const VanillaSwap> &swap, const boost::shared_ptr<const Counterparty> &issuer, const boost::shared_ptr<const CoxIngersollRoss> &cirModel, const Matrix &corr, Size timeStepsPerYear/* = 360*/, bool antitheticVariate/* = true*/, Size requiredSamples/* = 50000*/, Real requiredTolerance/* = 0.0001*/, Size maxSamples/* = QL_MAX_INTEGER*/, BigNatural seed/* = SeedGenerator::instance().get()*/) : MCUCVAEngine(swap, issuer, corr, dayCounter.yearFraction(swap->startDate(), swap->maturityDate(), referenceDate, referenceDate), riskFreeTermStructure, Null<Size>(), 360, true, requiredSamples, requiredTolerance, maxSamples, seed), cirModel_(cirModel) { }
inline TimeGrid MCDiscreteAveragingAsianEngine<RNG,S>::timeGrid() const { Date referenceDate = process_->riskFreeRate()->referenceDate(); DayCounter voldc = process_->blackVolatility()->dayCounter(); std::vector<Time> fixingTimes; Size i; for (i=0; i<arguments_.fixingDates.size(); i++) { if (arguments_.fixingDates[i]>=referenceDate) { Time t = voldc.yearFraction(referenceDate, arguments_.fixingDates[i]); fixingTimes.push_back(t); } } return TimeGrid(fixingTimes.begin(), fixingTimes.end()); }