BlackKarasinski::BlackKarasinski( const Handle<YieldTermStructure>& termStructure, Real a, Real sigma) : OneFactorModel(2), TermStructureConsistentModel(termStructure), a_(arguments_[0]), sigma_(arguments_[1]) { a_ = ConstantParameter(a, PositiveConstraint()); sigma_ = ConstantParameter(sigma, PositiveConstraint()); registerWith(termStructure); }
LmLinearExponentialVolatilityModel::LmLinearExponentialVolatilityModel( const std::vector<Time>& fixingTimes, Real a, Real b, Real c, Real d) : LmVolatilityModel(fixingTimes.size(), 4), fixingTimes_(fixingTimes) { arguments_[0] = ConstantParameter(a, PositiveConstraint()); arguments_[1] = ConstantParameter(b, PositiveConstraint()); arguments_[2] = ConstantParameter(c, PositiveConstraint()); arguments_[3] = ConstantParameter(d, PositiveConstraint()); }
BatesDetJumpModel::BatesDetJumpModel( const boost::shared_ptr<BatesProcess> & process, Real kappaLambda, Real thetaLambda) : BatesModel(process) { arguments_.resize(10); arguments_[8] = ConstantParameter(kappaLambda, PositiveConstraint()); arguments_[9] = ConstantParameter(thetaLambda, PositiveConstraint()); }
BatesDoubleExpDetJumpModel::BatesDoubleExpDetJumpModel( const boost::shared_ptr<HestonProcess> & process, Real lambda, Real nuUp, Real nuDown, Real p, Real kappaLambda, Real thetaLambda) : BatesDoubleExpModel(process, lambda, nuUp, nuDown, p) { arguments_.resize(11); arguments_[9] = ConstantParameter(kappaLambda, PositiveConstraint()); arguments_[10] = ConstantParameter(thetaLambda, PositiveConstraint()); }
BatesDoubleExpModel::BatesDoubleExpModel( const boost::shared_ptr<HestonProcess> & process, Real lambda, Real nuUp, Real nuDown, Real p) : HestonModel(process) { arguments_.resize(9); arguments_[5] = ConstantParameter(p, BoundaryConstraint(0.0, 1.0)); arguments_[6] = ConstantParameter(nuDown, PositiveConstraint()); arguments_[7] = ConstantParameter(nuUp, PositiveConstraint()); arguments_[8] = ConstantParameter(lambda, PositiveConstraint()); }
BatesModel::BatesModel(const boost::shared_ptr<BatesProcess> & process) : HestonModel(process) { arguments_.resize(8); arguments_[5] = ConstantParameter(process->nu(), NoConstraint()); arguments_[6] = ConstantParameter(process->delta(), PositiveConstraint()); arguments_[7] = ConstantParameter(process->lambda(), PositiveConstraint()); generateArguments(); }
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); }
PiecewiseTimeDependentHestonModel::PiecewiseTimeDependentHestonModel( const Handle<YieldTermStructure>& riskFreeRate, const Handle<YieldTermStructure>& dividendYield, const Handle<Quote>& s0, Real v0, const Parameter& theta, const Parameter& kappa, const Parameter& sigma, const Parameter& rho, const TimeGrid& timeGrid) : CalibratedModel(5), s0_ (s0), riskFreeRate_ (riskFreeRate), dividendYield_(dividendYield), timeGrid_ (timeGrid) { arguments_[0] = theta; arguments_[1] = kappa; arguments_[2] = sigma; arguments_[3] = rho; arguments_[4] = ConstantParameter(v0, PositiveConstraint()); registerWith(s0); registerWith(riskFreeRate); registerWith(dividendYield); }
LmExtLinearExponentialVolModel::LmExtLinearExponentialVolModel( const std::vector<Time>& fixingTimes, Real a, Real b, Real c, Real d) : LmLinearExponentialVolatilityModel(fixingTimes, a, b, c, d) { arguments_.resize(4+size_); for (Size i=0; i <size_; ++i) { arguments_[i+4] = ConstantParameter(1.0, PositiveConstraint()); } }
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); }