// Handle<YieldTermStructure> discountCurve = Handle<YieldTermStructure>()); public ForwardRateAgreement(Date valueDate, Date maturityDate, Position.Type type, double strikeForwardRate, double notionalAmount, IborIndex index, Handle<YieldTermStructure> discountCurve) : base(index.dayCounter(), index.fixingCalendar(), index.businessDayConvention(), index.fixingDays(), new Payoff(), valueDate, maturityDate, discountCurve) { fraType_ = type; notionalAmount_ = notionalAmount; index_ = index; if (notionalAmount <= 0.0) throw new ApplicationException("notional Amount must be positive"); // do I adjust this ? // valueDate_ = calendar_.adjust(valueDate_,businessDayConvention_); Date fixingDate = calendar_.advance(valueDate_, -settlementDays_, TimeUnit.Days); forwardRate_ = new InterestRate(index.fixing(fixingDate), index.dayCounter(), Compounding.Simple, Frequency.Once); strikeForwardRate_ = new InterestRate(strikeForwardRate, index.dayCounter(), Compounding.Simple, Frequency.Once); double strike = notionalAmount_ * strikeForwardRate_.compoundFactor(valueDate_, maturityDate_); payoff_ = new ForwardTypePayoff(fraType_, strike); // incomeDiscountCurve_ is irrelevant to an FRA incomeDiscountCurve_ = discountCurve_; // income is irrelevant to FRA - set it to zero underlyingIncome_ = 0.0; index_.registerWith(update); }
public VanillaSwap value() { Date startDate; if (effectiveDate_ != null) { startDate = effectiveDate_; } else { int fixingDays = iborIndex_.fixingDays(); Date referenceDate = Settings.evaluationDate(); Date spotDate = floatCalendar_.advance(referenceDate, new Period(fixingDays, TimeUnit.Days)); startDate = spotDate + forwardStart_; } Date endDate; if (terminationDate_ != null) { endDate = terminationDate_; } else { endDate = startDate + swapTenor_; } Schedule fixedSchedule = new Schedule(startDate, endDate, fixedTenor_, fixedCalendar_, fixedConvention_, fixedTerminationDateConvention_, fixedRule_, fixedEndOfMonth_, fixedFirstDate_, fixedNextToLastDate_); Schedule floatSchedule = new Schedule(startDate, endDate, floatTenor_, floatCalendar_, floatConvention_, floatTerminationDateConvention_, floatRule_, floatEndOfMonth_, floatFirstDate_, floatNextToLastDate_); double?usedFixedRate = fixedRate_; if (fixedRate_ == null) // calculate a fair fixed rate if no fixed rate is provided { if (iborIndex_.forwardingTermStructure().empty()) { throw new ArgumentException("no forecasting term structure set to " + iborIndex_.name()); } VanillaSwap temp = new VanillaSwap(type_, nominal_, fixedSchedule, 0.0, fixedDayCount_, floatSchedule, iborIndex_, floatSpread_, floatDayCount_); temp.setPricingEngine(new DiscountingSwapEngine(iborIndex_.forwardingTermStructure())); usedFixedRate = temp.fairRate(); } VanillaSwap swap = new VanillaSwap(type_, nominal_, fixedSchedule, usedFixedRate.Value, fixedDayCount_, floatSchedule, iborIndex_, floatSpread_, floatDayCount_); swap.setPricingEngine(engine_); return(swap); }
public DepositRateHelper(double rate, IborIndex i) : base(rate) { iborIndex_ = new IborIndex("no-fix", // never take fixing into account i.tenor(), i.fixingDays(), new Currency(), i.fixingCalendar(), i.businessDayConvention(), i.endOfMonth(), i.dayCounter(), termStructureHandle_); initializeDates(); }
public DepositRateHelper(double rate, IborIndex i) : base(rate) { iborIndex_ = new IborIndex("no-fix", // never take fixing into account i.tenor(), i.fixingDays(), new Currency(), i.fixingCalendar(), i.businessDayConvention(), i.endOfMonth(), i.dayCounter(), termStructureHandle_); initializeDates(); }
protected override void initializeDates() { // why not using index_->fixingDays instead of settlementDays_ Date settlement = iborIndex_.fixingCalendar().advance(evaluationDate_, iborIndex_.fixingDays(), TimeUnit.Days); earliestDate_ = iborIndex_.fixingCalendar().advance(settlement, periodToStart_, iborIndex_.businessDayConvention(), iborIndex_.endOfMonth()); latestDate_ = iborIndex_.maturityDate(earliestDate_); fixingDate_ = iborIndex_.fixingDate(earliestDate_); }
public FraRateHelper(double rate, int monthsToStart, IborIndex i) : base(rate) { periodToStart_ = new Period(monthsToStart, TimeUnit.Months); iborIndex_ = new IborIndex("no-fix", // never take fixing into account i.tenor(), i.fixingDays(), new Currency(), i.fixingCalendar(), i.businessDayConvention(), i.endOfMonth(), i.dayCounter(), termStructureHandle_); initializeDates(); }
public FRARateHelper(double rate, int monthsToStart, IborIndex i) : base(rate) { periodToStart_ = new Period(monthsToStart, TimeUnit.Months); iborIndex_ = new IborIndex("no-fix", // never take fixing into account i.tenor(), i.fixingDays(), new Currency(), i.fixingCalendar(), i.businessDayConvention(), i.endOfMonth(), i.dayCounter(), termStructureHandle_); initializeDates(); }
public BMASwap(Type type, double nominal, // Libor leg Schedule liborSchedule, double liborFraction, double liborSpread, IborIndex liborIndex, DayCounter liborDayCount, // BMA leg Schedule bmaSchedule, BMAIndex bmaIndex, DayCounter bmaDayCount) : base(2) { type_ = type; nominal_ = nominal; liborFraction_ = liborFraction; liborSpread_ = liborSpread; BusinessDayConvention convention = liborSchedule.businessDayConvention(); legs_[0] = new IborLeg(liborSchedule, liborIndex) .withPaymentDayCounter(liborDayCount) .withFixingDays(liborIndex.fixingDays()) .withGearings(liborFraction) .withSpreads(liborSpread) .withNotionals(nominal) .withPaymentAdjustment(convention); legs_[1] = new AverageBMALeg(bmaSchedule, bmaIndex) .withPaymentDayCounter(bmaDayCount) .withNotionals(nominal) .withPaymentAdjustment(bmaSchedule.businessDayConvention()); for (int j = 0; j < 2; ++j) { for (int i = 0; i < legs_[j].Count; i++) { legs_[j][i].registerWith(update); } } switch (type_) { case Type.Payer: payer_[0] = +1.0; payer_[1] = -1.0; break; case Type.Receiver: payer_[0] = -1.0; payer_[1] = +1.0; break; default: Utils.QL_FAIL("Unknown BMA-swap type"); break; } }
public SwaptionHelper(Period maturity, Period length, Handle <Quote> volatility, IborIndex index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, Handle <YieldTermStructure> termStructure, bool calibrateVolatility /*= false*/) : base(volatility, termStructure, calibrateVolatility) { Calendar calendar = index.fixingCalendar(); Period indexTenor = index.tenor(); int fixingDays = index.fixingDays(); Date exerciseDate = calendar.advance(termStructure.link.referenceDate(), maturity, index.businessDayConvention()); Date startDate = calendar.advance(exerciseDate, fixingDays, TimeUnit.Days, index.businessDayConvention()); Date endDate = calendar.advance(startDate, length, index.businessDayConvention()); Schedule fixedSchedule = new Schedule(startDate, endDate, fixedLegTenor, calendar, index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); Schedule floatSchedule = new Schedule(startDate, endDate, index.tenor(), calendar, index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); IPricingEngine swapEngine = new DiscountingSwapEngine(termStructure); VanillaSwap temp = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0, fixedSchedule, 0.0, fixedLegDayCounter, floatSchedule, index, 0.0, floatingLegDayCounter); temp.setPricingEngine(swapEngine); exerciseRate_ = temp.fairRate(); swap_ = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0, fixedSchedule, exerciseRate_, fixedLegDayCounter, floatSchedule, index, 0.0, floatingLegDayCounter); swap_.setPricingEngine(swapEngine); Exercise exercise = new EuropeanExercise(exerciseDate); swaption_ = new Swaption(swap_, exercise); marketValue_ = blackPrice(volatility_.link.value()); }
public SwaptionHelper(Period maturity, Period length, Handle<Quote> volatility, IborIndex index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, Handle<YieldTermStructure> termStructure, bool calibrateVolatility /*= false*/) : base(volatility,termStructure, calibrateVolatility) { Calendar calendar = index.fixingCalendar(); Period indexTenor = index.tenor(); int fixingDays = index.fixingDays(); Date exerciseDate = calendar.advance(termStructure.link.referenceDate(), maturity, index.businessDayConvention()); Date startDate = calendar.advance(exerciseDate, fixingDays, TimeUnit.Days, index.businessDayConvention()); Date endDate = calendar.advance(startDate, length, index.businessDayConvention()); Schedule fixedSchedule=new Schedule(startDate, endDate, fixedLegTenor, calendar, index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); Schedule floatSchedule=new Schedule(startDate, endDate, index.tenor(), calendar, index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); IPricingEngine swapEngine=new DiscountingSwapEngine(termStructure); VanillaSwap temp=new VanillaSwap(VanillaSwap.Type.Receiver, 1.0, fixedSchedule, 0.0, fixedLegDayCounter, floatSchedule, index, 0.0, floatingLegDayCounter); temp.setPricingEngine(swapEngine); exerciseRate_ = temp.fairRate(); swap_ = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0, fixedSchedule, exerciseRate_, fixedLegDayCounter, floatSchedule, index, 0.0, floatingLegDayCounter); swap_.setPricingEngine(swapEngine); Exercise exercise=new EuropeanExercise(exerciseDate); swaption_ = new Swaption(swap_, exercise); marketValue_ = blackPrice(volatility_.link.value()); }
public BasisSwap value() { Date startDate; if (effectiveDate_ != null) { startDate = effectiveDate_; } else { int fixingDays = iborIndex1_.fixingDays(); Date referenceDate = Settings.evaluationDate(); Date spotDate = float1Calendar_.advance(referenceDate, new Period(fixingDays, TimeUnit.Days)); startDate = spotDate + forwardStart_; } Date endDate; if (terminationDate_ != null) { endDate = terminationDate_; } else { endDate = startDate + swapTenor_; } Schedule float1Schedule = new Schedule(startDate, endDate, float1Tenor_, float1Calendar_, float1Convention_, float1TerminationDateConvention_, float1Rule_, float1EndOfMonth_, float1FirstDate_, float1NextToLastDate_); Schedule float2Schedule = new Schedule(startDate, endDate, float2Tenor_, float2Calendar_, float2Convention_, float2TerminationDateConvention_, float2Rule_, float2EndOfMonth_, float2FirstDate_, float2NextToLastDate_); BasisSwap swap = new BasisSwap(type_, nominal_, float1Schedule, iborIndex1_, float1Spread_, float1DayCount_, float2Schedule, iborIndex2_, float2Spread_, float2DayCount_); swap.setPricingEngine(engine_); return(swap); }
public BMASwap(Type type, double nominal, // Libor leg Schedule liborSchedule, double liborFraction, double liborSpread, IborIndex liborIndex, DayCounter liborDayCount, // BMA leg Schedule bmaSchedule, BMAIndex bmaIndex, DayCounter bmaDayCount) : base(2) { type_ = type; nominal_ = nominal; liborFraction_ = liborFraction; liborSpread_ = liborSpread; BusinessDayConvention convention = liborSchedule.businessDayConvention(); legs_[0] = new IborLeg(liborSchedule, liborIndex) .withPaymentDayCounter(liborDayCount) .withFixingDays(liborIndex.fixingDays()) .withGearings(liborFraction) .withSpreads(liborSpread) .withNotionals(nominal) .withPaymentAdjustment(convention); legs_[1] = new AverageBMALeg(bmaSchedule, bmaIndex) .withPaymentDayCounter(bmaDayCount) .withNotionals(nominal) .withPaymentAdjustment(bmaSchedule.businessDayConvention()); for (int j=0; j<2; ++j) { for (int i=0; i<legs_[j].Count; i++) legs_[j][i].registerWith(update); } switch (type_) { case Type.Payer: payer_[0] = +1.0; payer_[1] = -1.0; break; case Type.Receiver: payer_[0] = -1.0; payer_[1] = +1.0; break; default: throw new ApplicationException("Unknown BMA-swap type"); } }
public List <CashFlow> cashFlows(double amount) { Date refDate = index_.forwardingTermStructure().link.referenceDate(); Schedule schedule = new Schedule(refDate, refDate + new Period(index_.tenor().length() * size_, index_.tenor().units()), index_.tenor(), index_.fixingCalendar(), index_.businessDayConvention(), index_.businessDayConvention(), DateGeneration.Rule.Forward, false); IborLeg cashflows = (IborLeg) new IborLeg(schedule, index_) .withFixingDays(index_.fixingDays()) .withPaymentDayCounter(index_.dayCounter()) .withNotionals(amount) .withPaymentAdjustment(index_.businessDayConvention()); return(cashflows.value()); }
public MakeVanillaSwap(Period swapTenor, IborIndex index, double?fixedRate = null, Period forwardStart = null) { swapTenor_ = swapTenor; iborIndex_ = index; fixedRate_ = fixedRate; forwardStart_ = forwardStart ?? new Period(0, TimeUnit.Days); settlementDays_ = iborIndex_.fixingDays(); fixedCalendar_ = floatCalendar_ = index.fixingCalendar(); type_ = VanillaSwap.Type.Payer; nominal_ = 1.0; //fixedTenor_ = new Period(1, TimeUnit.Years); floatTenor_ = index.tenor(); fixedConvention_ = fixedTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing; floatConvention_ = floatTerminationDateConvention_ = index.businessDayConvention(); fixedRule_ = floatRule_ = DateGeneration.Rule.Backward; fixedEndOfMonth_ = floatEndOfMonth_ = false; fixedFirstDate_ = fixedNextToLastDate_ = floatFirstDate_ = floatNextToLastDate_ = null; floatSpread_ = 0.0; //fixedDayCount_ = new Thirty360(Thirty360.Thirty360Convention.BondBasis); floatDayCount_ = index.dayCounter(); //engine_ = new DiscountingSwapEngine(index.forwardingTermStructure()); }
// Handle<YieldTermStructure> discountCurve = Handle<YieldTermStructure>()); public ForwardRateAgreement(Date valueDate, Date maturityDate, Position.Type type, double strikeForwardRate, double notionalAmount, IborIndex index, Handle <YieldTermStructure> discountCurve) : base(index.dayCounter(), index.fixingCalendar(), index.businessDayConvention(), index.fixingDays(), new Payoff(), valueDate, maturityDate, discountCurve) { fraType_ = type; notionalAmount_ = notionalAmount; index_ = index; if (notionalAmount <= 0.0) { throw new ApplicationException("notional Amount must be positive"); } // do I adjust this ? // valueDate_ = calendar_.adjust(valueDate_,businessDayConvention_); Date fixingDate = calendar_.advance(valueDate_, -settlementDays_, TimeUnit.Days); forwardRate_ = new InterestRate(index.fixing(fixingDate), index.dayCounter(), Compounding.Simple, Frequency.Once); strikeForwardRate_ = new InterestRate(strikeForwardRate, index.dayCounter(), Compounding.Simple, Frequency.Once); double strike = notionalAmount_ * strikeForwardRate_.compoundFactor(valueDate_, maturityDate_); payoff_ = new ForwardTypePayoff(fraType_, strike); // incomeDiscountCurve_ is irrelevant to an FRA incomeDiscountCurve_ = discountCurve_; // income is irrelevant to FRA - set it to zero underlyingIncome_ = 0.0; index_.registerWith(update); }
protected override void initializeDates() { earliestDate_ = iborIndex_.fixingCalendar().advance(evaluationDate_, iborIndex_.fixingDays(), TimeUnit.Days); latestDate_ = iborIndex_.maturityDate(earliestDate_); fixingDate_ = iborIndex_.fixingCalendar().advance(earliestDate_, -iborIndex_.fixingDays(), TimeUnit.Days); }
public CapHelper(Period length, Handle<Quote> volatility, IborIndex index, // data for ATM swap-rate calculation Frequency fixedLegFrequency, DayCounter fixedLegDayCounter, bool includeFirstSwaplet, Handle<YieldTermStructure> termStructure, bool calibrateVolatility /*= false*/) : base(volatility, termStructure, calibrateVolatility) { Period indexTenor = index.tenor(); double fixedRate = 0.04; // dummy value Date startDate, maturity; if (includeFirstSwaplet) { startDate = termStructure.link.referenceDate(); maturity = termStructure.link.referenceDate() + length; } else { startDate = termStructure.link.referenceDate() + indexTenor; maturity = termStructure.link.referenceDate() + length; } IborIndex dummyIndex=new IborIndex("dummy", indexTenor, index.fixingDays(), index.currency(), index.fixingCalendar(), index.businessDayConvention(), index.endOfMonth(), termStructure.link.dayCounter(), termStructure); List<double> nominals = new InitializedList<double>(1,1.0); Schedule floatSchedule=new Schedule(startDate, maturity, index.tenor(), index.fixingCalendar(), index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); List<CashFlow> floatingLeg; IborLeg iborLeg = (IborLeg) new IborLeg(floatSchedule, index) .withFixingDays(0) .withNotionals(nominals) .withPaymentAdjustment(index.businessDayConvention()); floatingLeg = iborLeg.value(); Schedule fixedSchedule=new Schedule(startDate, maturity, new Period(fixedLegFrequency), index.fixingCalendar(), BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Forward, false); List<CashFlow> fixedLeg = new FixedRateLeg(fixedSchedule) .withCouponRates(fixedRate, fixedLegDayCounter) .withNotionals(nominals) .withPaymentAdjustment(index.businessDayConvention()); Swap swap = new Swap(floatingLeg, fixedLeg); swap.setPricingEngine(new DiscountingSwapEngine(termStructure)); double bp = 1.0e-4; double fairRate = fixedRate - (double)(swap.NPV()/(swap.legBPS(1) / bp)); List<double> exerciceRate = new InitializedList<double>(1,fairRate); cap_ = new Cap(floatingLeg, exerciceRate); marketValue_ = blackPrice(volatility_.link.value()); }
public CapHelper(Period length, Handle <Quote> volatility, IborIndex index, // data for ATM swap-rate calculation Frequency fixedLegFrequency, DayCounter fixedLegDayCounter, bool includeFirstSwaplet, Handle <YieldTermStructure> termStructure, bool calibrateVolatility /*= false*/) : base(volatility, termStructure, calibrateVolatility) { Period indexTenor = index.tenor(); double fixedRate = 0.04; // dummy value Date startDate, maturity; if (includeFirstSwaplet) { startDate = termStructure.link.referenceDate(); maturity = termStructure.link.referenceDate() + length; } else { startDate = termStructure.link.referenceDate() + indexTenor; maturity = termStructure.link.referenceDate() + length; } IborIndex dummyIndex = new IborIndex("dummy", indexTenor, index.fixingDays(), index.currency(), index.fixingCalendar(), index.businessDayConvention(), index.endOfMonth(), termStructure.link.dayCounter(), termStructure); List <double> nominals = new InitializedList <double>(1, 1.0); Schedule floatSchedule = new Schedule(startDate, maturity, index.tenor(), index.fixingCalendar(), index.businessDayConvention(), index.businessDayConvention(), DateGeneration.Rule.Forward, false); List <CashFlow> floatingLeg; IborLeg iborLeg = (IborLeg) new IborLeg(floatSchedule, index) .withFixingDays(0) .withNotionals(nominals) .withPaymentAdjustment(index.businessDayConvention()); floatingLeg = iborLeg.value(); Schedule fixedSchedule = new Schedule(startDate, maturity, new Period(fixedLegFrequency), index.fixingCalendar(), BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Forward, false); List <CashFlow> fixedLeg = new FixedRateLeg(fixedSchedule) .withCouponRates(fixedRate, fixedLegDayCounter) .withNotionals(nominals) .withPaymentAdjustment(index.businessDayConvention()); Swap swap = new Swap(floatingLeg, fixedLeg); swap.setPricingEngine(new DiscountingSwapEngine(termStructure)); double bp = 1.0e-4; double fairRate = fixedRate - (double)(swap.NPV() / (swap.legBPS(1) / bp)); List <double> exerciceRate = new InitializedList <double>(1, fairRate); cap_ = new Cap(floatingLeg, exerciceRate); marketValue_ = blackPrice(volatility_.link.value()); }