///// <summary> ///// Initializes a new instance of the <see cref="PriceableFxSpotRate"/> class. ///// </summary> ///// <param name="baseDate">The base date.</param> ///// <param name="spotDateOffset">The business day adjustments.</param> ///// <param name="fxRateAsset"></param> ///// <param name="fxForward">The forward points.</param> //public PriceableFxTNRate(DateTime baseDate, RelativeDateOffset spotDateOffset, FxRateAsset fxRateAsset, BasicQuotation fxForward) // : this(1.0m, baseDate, fxRateAsset, // spotDateOffset, fxForward) //{} /// <summary> /// Initializes a new instance of the <see cref="PriceableFxSpotRate"/> class. /// </summary> /// <param name="notionalAmount">The notional.</param> /// <param name="baseDate">The base date.</param> /// <param name="nodeStruct">The nodeStruct.</param> /// <param name="fxRateAsset">The asset itself</param> /// <param name="fixingCalendar">The fixing Calendar.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="fxForward">The forward points.</param> public PriceableFxTNRate(DateTime baseDate, decimal notionalAmount, FxSpotNodeStruct nodeStruct, FxRateAsset fxRateAsset, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fxForward) : base(baseDate, "1D", notionalAmount, nodeStruct, fxRateAsset, fixingCalendar, paymentCalendar, fxForward) { AdjustedStartDate = baseDate; //AdjustedEffectiveDate = fixingCalendar.Advance(AdjustedStartDate, OffsetHelper.FromInterval(Tenor, DayTypeEnum.Business), SpotDateOffset.businessDayConvention); RiskMaturityDate = fixingCalendar.Advance(AdjustedStartDate, OffsetHelper.FromInterval(Tenor, DayTypeEnum.Business), SpotDateOffset.businessDayConvention); }
/// <summary> /// Initializes a new instance of the <see cref="RateSpreadCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="properties">The properties.</param> /// <param name="refCurve">The reference parent curveid.</param> /// <param name="value">The values.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public RateSpreadCurve(ILogger logger, ICoreCache cache, string nameSpace, NamedValueSet properties, IPricingStructure refCurve, Decimal value, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, AdjustMarketQuotes(value, refCurve.GetFpMLData(), PropertyHelper.ExtractUniqueCurveIdentifier(properties)), properties, fixingCalendar, rollCalendar) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, properties); ReferenceCurveId = refCurve.GetPricingStructureId(); }
/// <summary> /// Deal settle. /// </summary> /// <param name="dealDate"></param> /// <param name="settC"></param> /// <param name="hols"></param> /// <returns></returns> public static DateTime SettFromDeal(DateTime dealDate, BondSettlementEnum settC, IBusinessCalendar hols) { switch (settC) { case BondSettlementEnum.SC_dealDate: return(dealDate); case BondSettlementEnum.SC_1bd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(1), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_2bd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(2), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_1b1cd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(1), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING).AddDays(1)); case BondSettlementEnum.SC_3bd: case BondSettlementEnum.SC_3bd_6bdLO: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(3), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_3b1cd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(3), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING).AddDays(1)); case BondSettlementEnum.SC_4bd: case BondSettlementEnum.SC_4bd_6bdLO: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(4), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_5bd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(5), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_7bd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(7), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_3d: return(hols.Roll(dealDate.AddDays(3), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_7d: return(hols.Roll(dealDate.AddDays(7), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_7c1bd: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(7), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); case BondSettlementEnum.SC_3cd: return(hols.Roll(dealDate.AddDays(3), BusinessDayConventionEnum.FOLLOWING)); // case BondSettlementHelper.BondSettlementEnum.SC_Canada: // return default: return(hols.Advance(dealDate, OffsetHelper.FromInterval(IntervalHelper.FromDays(1), DayTypeEnum.Business), BusinessDayConventionEnum.FOLLOWING)); } /* switch (settC) * { * case SC_Canada: * CalendarDate(ym, mm, dm, maturityDate); * return TCs->NextBizDay(dealDate, 2 + (dealDate <= UnadjustedDate(ym - 3, mm, dm))); * * case SC_Austria: return TCs->NextBizDay(dealDate + 15 - DayOfWeek(dealDate), 0); * * case SC_Australia: * CalendarDate(ym, mm, dm, maturityDate); * return TCs->NextBizDay(dealDate, dealDate > UnadjustedDate(ym, mm - 6, dm) ? 1 : 3); * * case SC_SouthAfrica: * settDate = dealDate + 15 - DayOfWeek(dealDate + 4); * if (!TCs->IsBizDay(settDate + 1)) settDate--; * return settDate; * } * return dealDate;*/ }
/// <summary> /// Initializes a new instance of the <see cref="PriceableFxRateCashflow"/> class. /// </summary> /// <param name="cashlfowId">The stream id.</param> /// <param name="payerIsBase">The payer is base flag.</param> /// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param> /// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param> /// <param name="adjustAccrualDatesIndicator">if set to <c>true</c> [adjust calculation dates indicator].</param> /// <param name="accrualBusinessCenters">The accrual business centers.</param> /// <param name="margin">The margin.</param> /// <param name="baseRate">The base rate for a nettable fixed/floating cash flow. </param> /// <param name="observedRate">The observed Rate.</param> /// <param name="notionalAmount">The notional amount.</param> /// <param name="dayCountfraction">Type of day Countfraction.</param> /// <param name="paymentDate">The payment date.</param> /// <param name="accrualRollConvention">The accrual roll convention.</param> /// <param name="resetRelativeTo">reset relative to?</param> /// <param name="fixingDateRelativeOffset">The fixing date offset.</param> /// <param name="forecastRateIndex">The forecastrateindex.</param> /// <param name="discountingType">The swap discounting type.</param> /// <param name="discountRate">The discount rate.</param> /// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null, /// then it is assumed that there is no fradiscounting</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> public PriceableFloatingRateCoupon ( string cashlfowId , bool payerIsBase , DateTime accrualStartDate , DateTime accrualEndDate , Boolean adjustAccrualDatesIndicator , BusinessCenters accrualBusinessCenters , BusinessDayConventionEnum accrualRollConvention , DayCountFraction dayCountfraction , ResetRelativeToEnum resetRelativeTo , RelativeDateOffset fixingDateRelativeOffset , Decimal margin , Decimal baseRate , Decimal?observedRate , Money notionalAmount , AdjustableOrAdjustedDate paymentDate , ForecastRateIndex forecastRateIndex , DiscountingTypeEnum?discountingType , Decimal?discountRate , FraDiscountingEnum?fraDiscounting , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) : base( cashlfowId , CouponType.FloatingRate , payerIsBase , accrualStartDate , accrualEndDate , adjustAccrualDatesIndicator , accrualBusinessCenters , accrualRollConvention , dayCountfraction , observedRate , notionalAmount , paymentDate , discountingType , discountRate , fraDiscounting , paymentCalendar) { BaseRate = baseRate; FixingCalendar = fixingCalendar; ModelIdentifier = "DualCurveCouponModel"; Id = cashlfowId; ForwardStartDate = AccrualStartDate; ForecastRateIndex = forecastRateIndex; FixingDateRelativeOffset = fixingDateRelativeOffset; ResetRelativeTo = resetRelativeTo; Margin = margin; AdjustedFixingDate = GetResetDate(resetRelativeTo, fixingDateRelativeOffset); if (observedRate != null) { RateObservation = RateObservationHelper.Parse(AdjustedFixingDate, (decimal)observedRate, "1"); } SetRateObservation(RateObservation, ResetDate); ForecastCurveName = CurveNameHelpers.GetForecastCurveName(forecastRateIndex); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableBondCouponRateStream"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace.</param> /// <param name="bondId">The bond Id.</param> /// <param name="paymentConvention">The payment roll conventions</param> /// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate /// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> /// <param name="tradeDate">The trade date is used to set the base date for future coupon generation.</param> /// <param name="notionalAmount">The notional amount</param> /// <param name="couponType">The coupon type: fixed or floating.</param> /// <param name="bond">THe bond details.</param> public PriceableBondCouponRateStream ( ILogger logger , ICoreCache cache , string nameSpace , string bondId , DateTime tradeDate , decimal notionalAmount , CouponStreamType couponType , Bond bond , BusinessDayAdjustments paymentConvention , bool forecastRateInterpolation , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) { BondId = bondId; Multiplier = 1.0m; PaymentCurrencies = new List <string>(); AnalyticsModel = new BondStreamAnalytic(); BondCouponStreamType = couponType; Id = BuildId(bondId, BondCouponStreamType); Currency = bond.currency.Value; ForecastRateInterpolation = forecastRateInterpolation; //Get the currency. if (!PaymentCurrencies.Contains(bond.currency.Value)) { PaymentCurrencies.Add(bond.currency.Value); } //The calendars if (paymentCalendar == null) { paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, paymentConvention.businessCenters, nameSpace); } //Set the default discount curve name. BondCurveName = CurveNameHelpers.GetBondCurveName(Currency, bondId); //Set the forecast curve name.//TODO extend this to the other types. //if (BondCouponStreamType != CouponStreamType.GenericFixedRate) //{ // if (fixingCalendar == null) // { // fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ResetDates.resetDatesAdjustments.businessCenters, nameSpace); // } // ForecastCurveName = null; // //if (Calculation.Items != null) // //{ // // var floatingRateCalculation = Calculation.Items; // // var floatingRateIndex = (FloatingRateCalculation) floatingRateCalculation[0]; // // ForecastCurveName = CurveNameHelpers.GetForecastCurveName(floatingRateIndex); // //} //} //Build the coupons and principal exchanges. Coupons = PriceableInstrumentsFactory.CreatePriceableBondCoupons(tradeDate, bond, notionalAmount, BondCouponStreamType, paymentConvention, ForecastRateInterpolation, fixingCalendar, paymentCalendar);//TODO add the stub calculation. UpdateCouponDiscountCurveNames(); UpdateCouponIds(); //RiskMaturityDate = ; logger.LogInfo("Bond Coupon Stream built"); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableCapFloorCoupon"/> class. /// </summary> /// <param name="cashlFowId">The stream id.</param> /// <param name="buyerIsBase">The buyer is base flag.</param> /// <param name="capStrike">The Cap strike.</param> /// <param name="floorStrike">The floor strike.</param> /// <param name="accrualStartDate">The accrual start date. If adjusted, the adjustCalculationDatesIndicator should be false.</param> /// <param name="accrualEndDate">The accrual end date. If adjusted, the adjustCalculationDatesIndicator should be false.</param> /// <param name="margin">The margin.</param> /// <param name="observedRate">The observed Rate. If this is not null, then it is used.</param> /// <param name="notionalAmount">The notional amount.</param> /// <param name="adjustedFixingDate">The adjusted fixing date.</param> /// <param name="dayCountFraction">Type of day Count fraction.</param> /// <param name="paymentDate">The payment date.</param> /// <param name="forecastRateIndex">The forecast rate index.</param> /// <param name="discountingType">The swap discounting type.</param> /// <param name="discountRate">The discount rate.</param> /// <param name="fraDiscounting">Determines whether the coupon is discounted or not. If this parameter is null, /// then it is assumed that there is no fra discounting</param> /// <param name="fixingCalendar"> The fixingCalendar. </param> /// <param name="paymentCalendar"> The paymentCalendar. </param> public PriceableCapFloorCoupon ( string cashlFowId , bool buyerIsBase , decimal?capStrike , decimal?floorStrike , DateTime accrualStartDate , DateTime accrualEndDate , DateTime adjustedFixingDate , DayCountFraction dayCountFraction , Decimal margin , Decimal?observedRate , Money notionalAmount , DateTime paymentDate , ForecastRateIndex forecastRateIndex , DiscountingTypeEnum?discountingType , Decimal?discountRate , FraDiscountingEnum?fraDiscounting , IBusinessCalendar fixingCalendar , IBusinessCalendar paymentCalendar) : base( cashlFowId , buyerIsBase , accrualStartDate , accrualEndDate , adjustedFixingDate , dayCountFraction , margin , observedRate , notionalAmount , paymentDate , forecastRateIndex , discountingType , discountRate , fraDiscounting , fixingCalendar , paymentCalendar) { CapStrike = capStrike; FloorStrike = floorStrike; VolatilitySurfaceName = CurveNameHelpers.GetRateVolatilityMatrixName(forecastRateIndex); if (capStrike != null && floorStrike == null) { PriceableCouponType = CouponType.Cap; ModelIdentifier = "DualCurveCapModel"; IsCall = true; } if (floorStrike != null && capStrike == null) { PriceableCouponType = CouponType.Floor; ModelIdentifier = "DualCurveFloorModel"; } if (floorStrike != null && capStrike != null) { PriceableCouponType = CouponType.Collar; ModelIdentifier = "DualCurveCollarModel"; } }
private static InterestRateStream GetCashflowsSchedule(IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, CapFloorLegParametersRange legParametersRange) { InterestRateStream stream = InterestRateStreamParametricDefinitionGenerator.GenerateStreamDefinition(legParametersRange); Cashflows cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream, fixingCalendar, paymentCalendar); stream.cashflows = cashflows; return(stream); }
/// <summary> /// Initializes a new instance of the <see cref="RateSpreadCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="referenceCurve">The reference parent curve id.</param> /// <param name="spreadAssets">The spreads by asset.</param> /// <param name="properties">The properties of the new spread curve.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public RateSpreadCurve(ILogger logger, ICoreCache cache, string nameSpace, IRateCurve referenceCurve, QuotedAssetSet spreadAssets, NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, ProcessQuotedAssetSet(logger, cache, nameSpace, referenceCurve, spreadAssets, properties, fixingCalendar, rollCalendar), properties, fixingCalendar, rollCalendar) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, properties); BaseCurve = referenceCurve; ReferenceCurveId = BaseCurve.GetPricingStructureId(); }
/////<summary> /////</summary> /////<returns></returns> //public decimal GetSpotRate() //{ // var fxVal = (FxCurveValuation)GetFpMLData().Second; // BasicAssetValuation spotRateAsset = (from spotRateAssets in fxVal.spotRate.assetQuote // where spotRateAssets.objectReference.href.EndsWith("-Equity-SP", StringComparison.InvariantCultureIgnoreCase)//TODO FIX This! // select spotRateAssets).Single(); // decimal spotRate = spotRateAsset.quote[0].value; // return spotRate; //} /// <summary> /// /// </summary> /// <param name="logger"></param> /// <param name="cache"></param> /// <param name="nameSpace">THe client namespace</param> /// <param name="equityId">THe curve asset.</param> /// <param name="fixingCalendar"></param> /// <param name="rollCalendar"></param> /// <param name="baseDate"></param> /// <returns></returns> protected static DateTime GetSettlementDate(ILogger logger, ICoreCache cache, string nameSpace, EquityCurveIdentifier equityId, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar, DateTime baseDate) { BasicAssetValuation bav = BasicAssetValuationHelper.Create(BasicQuotationHelper.Create(0, "MarketQuote", PriceQuoteUnitsEnum.Price.ToString())); var assetId = BuildSpotAssetId(equityId); var priceableAsset = (IPriceableEquityAssetController)PriceableAssetFactory.Create(logger, cache, nameSpace, assetId, baseDate, bav, fixingCalendar, rollCalendar); return(priceableAsset.GetRiskMaturityDate()); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleBond"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="nodeStruct">The bond nodeStruct</param> /// <param name="settlementCalendar">The settlement Calendar.</param> /// <param name="marketQuote">The market quote.</param> /// <param name="quoteType">THe quote Type</param> public PriceableBondSpot(DateTime baseDate, BondNodeStruct nodeStruct, IBusinessCalendar settlementCalendar, BasicQuotation marketQuote, BondPriceEnum quoteType) : base(baseDate, nodeStruct.Bond.faceAmount, nodeStruct.Bond.currency, nodeStruct.SettlementDate, nodeStruct.ExDivDate, nodeStruct.BusinessDayAdjustments, marketQuote, quoteType) { Id = nodeStruct.Bond.id; SettlementDateCalendar = settlementCalendar; //Get the settlement date SettlementDate = GetSettlementDate(baseDate, settlementCalendar, nodeStruct.SettlementDate); MaturityDate = SettlementDate; }
/// <summary> /// Initializes a new instance of the <see cref="PriceableIRFloor"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="identifier">The asset identifier.</param> /// <param name="rollDates">The roll dates. plus the maturity date. This array is an element longer than /// the notionals and strikes arrays.</param> /// <param name="notionals">The notionals for each caplet. There should be ne less than the number of roll dates.</param> /// <param name="strikes">The various strikes for each caplet. The same length as the notional list.</param> /// <param name="resets">An array of reset rates. This may be null.</param> /// <param name="resetOffset">The relative date offset for all the fixings.</param> /// <param name="paymentBusinessDayAdjustments">The payment business day adjustments.</param> /// <param name="capCalculation">The cap calculation.</param> /// <param name="fixingCalendar">The fixing Calendar.</param> public PriceableIRFloor(DateTime baseDate, string identifier, List <DateTime> rollDates, List <double> notionals, List <double> strikes, List <double> resets, RelativeDateOffset resetOffset, BusinessDayAdjustments paymentBusinessDayAdjustments, Calculation capCalculation, IBusinessCalendar fixingCalendar) : base(baseDate, identifier, rollDates, notionals, strikes, resets, resetOffset, paymentBusinessDayAdjustments, capCalculation, fixingCalendar) { IsCap = false; }
/// <summary> /// Calculate the end date of the FRA which /// will replace the cash instrument /// </summary> /// <param name="calendar"></param> /// <param name="assetController"></param> /// <returns></returns> public DateTime CalculateFraEndTime(IBusinessCalendar calendar, IPriceableRateAssetController assetController)//, //string currency, string rollConvention) { var deposit = (PriceableDeposit)assetController; BusinessDayConventionEnum adjustment = deposit.BusinessDayAdjustments.businessDayConvention; return(DatePeriodHelper.AddPeriod(assetController.GetRiskMaturityDate(), "3M", calendar, adjustment.ToString(), null)); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableXibor"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="amount">The amount.</param> /// <param name="nodeStruct">The nodeStruct.</param> /// <param name="fixingCalendar">The fixing Calendar.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="fixedRate"></param> public PriceableXibor(DateTime baseDate, Decimal amount, XiborNodeStruct nodeStruct, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate) : base(baseDate, amount, nodeStruct.RateIndex, nodeStruct.BusinessDayAdjustments, nodeStruct.SpotDate, fixedRate) { AdjustedStartDate = GetSpotDate(baseDate, fixingCalendar, nodeStruct.SpotDate); RiskMaturityDate = GetEffectiveDate(AdjustedStartDate, paymentCalendar, nodeStruct.RateIndex.term, nodeStruct.BusinessDayAdjustments.businessDayConvention); YearFraction = GetYearFraction(nodeStruct.RateIndex.dayCountFraction.Value, AdjustedStartDate, RiskMaturityDate); }
/// <summary> /// Initializes a new instance of the <see cref="RateBasisCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="spreadFpmlData">The FPML data.</param> /// <param name="properties">The properties</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public RateBasisCurve(ILogger logger, ICoreCache cache, string nameSpace, Pair <PricingStructure, PricingStructureValuation> spreadFpmlData, NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, spreadFpmlData, properties, fixingCalendar, rollCalendar) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, properties); var refCurveId = PropertyHelper.ExtractReferenceCurveUniqueId(properties); ReferenceCurveId = refCurveId != null ? new Identifier(refCurveId) : ReferenceCurveId = null; }
protected static Cashflows BuildCashflow(InterestRateStream stream, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar) { var cashflows = stream.cashflows; if (stream.cashflows == null || stream.cashflows.cashflowsMatchParameters == false) { cashflows = FixedAndFloatingRateStreamCashflowGenerator.GetCashflows(stream, fixingCalendar, paymentCalendar); } return(cashflows); }
public virtual IBusinessCalendar GetBusinessCalendar(string businessCalendarRef) { IBusinessCalendar businessCalendar = businessCalendars[businessCalendarRef]; if (businessCalendar == null) { throw new ActivitiException("Requested business calendar " + businessCalendarRef + " does not exist. Allowed calendars are " + this.businessCalendars.Keys + "."); } return(businessCalendar); }
/// <summary> /// Initializes a new instance of the <see cref="XccySpreadCurve"/> class, /// by applying spreads to an existing RateCurve. Using FX Curve to create synthetic swaps /// for the period under 1Y. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="properties">The properties of the new curve.</param> /// <param name="baseCurve">The base zero curve.</param> /// <param name="quoteCurve">The quote zero curve.</param> /// <param name="fxCurve">The FX curve, used for constructing synthetic deposits</param> /// <param name="inputs">The quoted asset instruments.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public XccySpreadCurve(ILogger logger, ICoreCache cache, String nameSpace, NamedValueSet properties, QuotedAssetSet inputs, IRateCurve baseCurve, IRateCurve quoteCurve, FxCurve fxCurve, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, new RateCurveIdentifier(properties)) { BasicAssetValuation[] assetQuote = inputs.assetQuote; string[] instruments = ExtractInstruments(assetQuote, null); decimal[] values = ExtractValues(assetQuote, null); Initialize(logger, cache, nameSpace, properties, baseCurve, quoteCurve, instruments, values, fxCurve, fixingCalendar, rollCalendar); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableBankBill"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="amount">Notional Amount.</param> /// <param name="nodeStruct">The deposit nodeStruct.</param> /// <param name="businessDayAdjustments">The business day adjustments.</param> /// <param name="fixingCalendar">The fixing Calendar.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="fixedRate">The fixed rate.</param> public PriceableBankBill(DateTime baseDate, Decimal amount, BankBillNodeStruct nodeStruct, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BusinessDayAdjustments businessDayAdjustments, BasicQuotation fixedRate) : base(nodeStruct.Deposit.id, baseDate, amount, businessDayAdjustments, fixedRate) { SpotDateOffset = nodeStruct.SpotDate; BankBill = nodeStruct.Deposit; AdjustedStartDate = GetSpotDate(baseDate, fixingCalendar, nodeStruct.SpotDate); RiskMaturityDate = GetEffectiveDate(AdjustedStartDate, paymentCalendar, nodeStruct.Deposit.term, nodeStruct.BusinessDayAdjustments.businessDayConvention); YearFraction = GetYearFraction(BankBill.dayCountFraction.Value, AdjustedStartDate, RiskMaturityDate); }
/// <summary> /// Initializes a new instance of the <see cref="SecuredRateCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="fpmlData">The FPML data.</param> /// <param name="properties">The properties.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public SecuredRateCurve(ILogger logger, ICoreCache cache, string nameSpace, Pair <PricingStructure, PricingStructureValuation> fpmlData, NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, fpmlData, properties, fixingCalendar, rollCalendar) { var refId = properties.GetValue <String>(BondProp.ReferenceBond, true); var refItem = cache.LoadItem <Bond>(nameSpace + '.' + "ReferenceData.FixedIncome." + refId); var refAsset = refItem.Data as Bond; UnderlyingAsset = refAsset; }
/// <summary> /// /// </summary> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <param name="properties"></param> /// <returns></returns> protected IBusinessCalendar ExtractPaymentCalendar(ICoreCache cache, string nameSpace, NamedValueSet properties) { string[] paymentCalendars = properties.GetArray <string>("PaymentCenters"); IBusinessCalendar paymentCalendar = null; if (paymentCalendars != null) { paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, paymentCalendars, nameSpace); } return(paymentCalendar); }
/// <summary> /// /// </summary> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <param name="properties"></param> /// <returns></returns> protected IBusinessCalendar ExtractFixingCalendar(ICoreCache cache, string nameSpace, NamedValueSet properties) { string[] fixingCalendars = properties.GetArray <string>("FixingCenters"); IBusinessCalendar fixingCalendar = null; if (fixingCalendars != null) { fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixingCalendars, nameSpace); } return(fixingCalendar); }
///<summary> ///</summary> public DateTime GetSettlementDate(DateTime baseDate, IBusinessCalendar settlementCalendar, RelativeDateOffset settlementDateOffset) { try { return(settlementCalendar.Advance(baseDate, settlementDateOffset, settlementDateOffset.businessDayConvention)); } catch (System.Exception) { throw new System.Exception("No settlement calendar set."); } }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleIRSwap"/> class. /// </summary> /// <param name="amount">The amount.</param> /// <param name="discountingType">The discounting type.</param> /// <param name="effectiveDate">The base date.</param> /// <param name="tenor">The maturity tenor.</param> /// <param name="fxdDayFraction">The fixed leg day fraction.</param> /// <param name="businessCenters">The payment business centers.</param> /// <param name="businessDayConvention">The payment business day convention.</param> /// <param name="fxdFrequency">The business day adjustments.</param> /// <param name="underlyingRateIndex">Index of the rate.</param> /// <param name="fixedRate">The fixed rate.</param> /// <param name="id">The identifier.</param> /// <param name="baseDate">The base date.</param> /// <param name="currency">THe currency.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> public PriceableSimpleIRSwap(string id, DateTime baseDate, string currency, decimal amount, DiscountingTypeEnum?discountingType, DateTime effectiveDate, string tenor, string fxdDayFraction, string businessCenters, string businessDayConvention, string fxdFrequency, RateIndex underlyingRateIndex, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate) : this(baseDate, SimpleIrsHelper.Parse(id, currency, fxdDayFraction, tenor, fxdFrequency, id), effectiveDate, CalculationFactory.CreateFixed(fixedRate.value, MoneyHelper.GetAmount(amount, currency), DayCountFractionHelper.Parse(fxdDayFraction), discountingType), BusinessDayAdjustmentsHelper.Create(businessDayConvention, businessCenters), underlyingRateIndex, fixingCalendar, paymentCalendar, fixedRate) { }
/// <summary> /// Builds this instance. /// </summary> public override void Build(ILogger logger, ICoreCache cache, string nameSpace, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) { PriceableCommodityAssets = PriceableAssetFactory.CreatePriceableCommodityAssets(logger, cache, nameSpace, GetFxCurveValuation().baseDate.Value, GetFxCurveValuation().spotRate, fixingCalendar, rollCalendar); var termCurve = ((FxCurveValuation)PricingStructureValuation).fxForwardCurve; termCurve.point = CommodityBootstrapper.Bootstrap(PriceableCommodityAssets, GetFxCurveValuation().baseDate.Value, termCurve.extrapolationPermitted, termCurve.interpolationMethod); SetFpMLData(new Pair <PricingStructure, PricingStructureValuation>(PricingStructure, PricingStructureValuation)); SetInterpolator(GetFxCurveValuation().baseDate.Value, Holder); }
/// <summary> /// Process a PPD Grid. The result is a Market structure that camn be published. /// </summary> /// <param name="logger">The logger</param> /// <param name="cache">The cache.</param> /// <param name="swapCurve">The latest rate curve</param> /// <param name="ppdGrid">The raw Points Per Day matrix supplied from the subscriber</param> /// <param name="id">The id to use in publishing the curve</param> /// <param name="nameSpace">The client namespace</param> /// <returns></returns> public static Market ProcessSwaption(ILogger logger, ICoreCache cache, Market swapCurve, SwaptionPPDGrid ppdGrid, string id, string nameSpace) { var mkt = swapCurve; var curve = new SimpleRateCurve(mkt); // List the values so we can build our ATM vols var atmVols = new Dictionary <SimpleKey, decimal>(); // Create a calendar to use to modify the date // default to be Sydney... IBusinessCalendar bc = BusinessCenterHelper.ToBusinessCalendar(cache, new[] { "AUSY" }, nameSpace); //BusinessCalendarHelper("AUSY"); // Use some logic to get the spot date to use // LPM Spot lag is 2 days (modfollowing) DateTime spotDate = curve.GetSpotDate(); // Extract each surface and build an ATM engine therefrom // Build a list of all possible engines foreach (string e in ExpiryKeys) { // Assume frequency = 4 months until 3 years tenor is reached Period expiration = PeriodHelper.Parse(e); double expiryYearFraction = expiration.ToYearFraction(); foreach (string t in TenorKeys) { // Create a Swaprate for each expiry/tenor pair // Assume frequency = 4 months until 3 years tenor is reached double tenorYearFraction = PeriodHelper.Parse(t).ToYearFraction(); int frequency = tenorYearFraction < 4 ? 4 : 2; // Calculation date // Discount factors // Offsets (elapsed days) var rates = new SwapRate(logger, cache, nameSpace, "AUSY", curve.BaseDate, "ACT/365.FIXED", curve.GetDiscountFactors(), curve.GetDiscountFactorOffsets(), frequency, BusinessDayConventionEnum.MODFOLLOWING); // Calculate the volatility given PPD and swap curve DateTime expiry = bc.Roll(expiration.Add(spotDate), BusinessDayConventionEnum.FOLLOWING); decimal vol = CalculateAtmVolatility(rates, expiry, ppdGrid, expiryYearFraction, tenorYearFraction); atmVols.Add(new SimpleKey(e, t), vol); } } var vols = new object[atmVols.Count + 1, 3]; var i = 1; vols[0, 0] = "Expiry"; vols[0, 1] = "Tenor"; vols[0, 2] = "0"; foreach (var key in atmVols.Keys) { vols[i, 0] = key.Expiry; vols[i, 1] = key.Tenor; vols[i, 2] = atmVols[key]; i++; } DateTime buildDateTime = swapCurve.Items1[0].buildDateTime; var volSurface = new VolatilitySurface(vols, new VolatilitySurfaceIdentifier(id), curve.BaseDate, buildDateTime); return(CreateMarketDocument(volSurface.GetFpMLData())); }
/// <summary> /// Adjusteds the dates from effective date. /// </summary> /// <param name="effectiveDate">The effective date.</param> /// <param name="terminationDate">The termination date.</param> /// <param name="periodInterval">The period interval.</param> /// <param name="rollConvention">The roll convention.</param> /// <param name="businessCenters">The business centers.</param> /// <param name="dateAdjustmentConvention">The date adjustment convention.</param> /// <returns>A vertical arrray of dates.</returns> public object[,] AdjustedDatesFromEffectiveDate(DateTime effectiveDate, DateTime terminationDate, string periodInterval, string rollConvention, string businessCenters, string dateAdjustmentConvention) { BusinessCenters centers = BusinessCentersHelper.Parse(businessCenters); IBusinessCalendar calendar = Engine.ToBusinessCalendar(centers); var adjustments = EnumHelper.Parse <BusinessDayConventionEnum>(dateAdjustmentConvention); var adjustedDateSchedule = AdjustedDateScheduler.AdjustedDatesFromEffectiveDate(effectiveDate, terminationDate, periodInterval, rollConvention, calendar, adjustments); var result = RangeHelper.ConvertArrayToRange(adjustedDateSchedule); return(result); }
/// <summary> /// /// </summary> /// <param name="timerEntity"></param> /// <param name="variableScope"></param> protected internal virtual void RestoreExtraData(IJobEntity timerEntity, IVariableScope variableScope) { string activityId = timerEntity.JobHandlerConfiguration; if (timerEntity.JobHandlerType.Equals(TimerStartEventJobHandler.TYPE, StringComparison.CurrentCultureIgnoreCase) || timerEntity.JobHandlerType.Equals(TriggerTimerEventJobHandler.TYPE, StringComparison.CurrentCultureIgnoreCase)) { activityId = TimerEventHandler.GetActivityIdFromConfiguration(timerEntity.JobHandlerConfiguration); string endDateExpressionString = TimerEventHandler.GetEndDateFromConfiguration(timerEntity.JobHandlerConfiguration); if (!(endDateExpressionString is null)) { IExpression endDateExpression = processEngineConfiguration.ExpressionManager.CreateExpression(endDateExpressionString); string endDateString = null; IBusinessCalendar businessCalendar = processEngineConfiguration.BusinessCalendarManager.GetBusinessCalendar(GetBusinessCalendarName(TimerEventHandler.GeCalendarNameFromConfiguration(timerEntity.JobHandlerConfiguration), variableScope)); if (endDateExpression != null) { object endDateValue = endDateExpression.GetValue(variableScope); if (endDateValue is string) { endDateString = (string)endDateValue; } else if (endDateValue is DateTime) { timerEntity.EndDate = (DateTime)endDateValue; } else { throw new ActivitiException("Timer '" + ((IExecutionEntity)variableScope).ActivityId + "' was not configured with a valid duration/time, either hand in a java.util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'"); } if (!timerEntity.EndDate.HasValue) { timerEntity.EndDate = businessCalendar.ResolveEndDate(endDateString).GetValueOrDefault(); } } } } int maxIterations = 1; if (!(timerEntity.ProcessDefinitionId is null)) { Process process = ProcessDefinitionUtil.GetProcess(timerEntity.ProcessDefinitionId); maxIterations = GetMaxIterations(process, activityId); if (maxIterations <= 1) { maxIterations = GetMaxIterations(process, activityId); } } timerEntity.MaxIterations = maxIterations; }
private static double GetParRateFromRange(ILogger logger, ICoreCache cache, IRateCurve forwardCurve, IRateCurve discountCurve, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, FraInputRange fraInputRange, String nameSpace) { Fra fra = ProductFactory.GetFpMLFra(fraInputRange); //var forwardCurve = ObjectCacheHelper.GetPricingStructureFromSerialisable(fraInputRange.ForwardCurveId); //var discountCurve = (RateCurve)ObjectCacheHelper.GetPricingStructureFromSerialisable(fraInputRange.DiscountingCurveId); var market = CreateMarket(discountCurve, forwardCurve); var priceInMoney = GetParRate(logger, cache, fixingCalendar, paymentCalendar, fra, fraInputRange.ValuationDate, market, nameSpace); return(priceInMoney); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableIRSwap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="nodeStruct">The nodeStruct;</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> /// <param name="fixedRate">The fixed rate.</param> public PriceableIRSwap(DateTime baseDate, SimpleIRSwapNodeStruct nodeStruct, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate) : base(baseDate, nodeStruct, fixingCalendar, paymentCalendar, fixedRate) { ModelIdentifier = DiscountingType == null ? "SwapAsset" : "DiscountSwapAsset"; //The floating leg which is now non-zero. var unadjustedDateSchedule = DateScheduler.GetUnadjustedDateSchedule(AdjustedStartDate, SimpleIRSwap.term, UnderlyingRateIndex.term); FloatingLegAdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(unadjustedDateSchedule, BusinessDayAdjustments.businessDayConvention, fixingCalendar); FloatingLegWeightings = CreateWeightings(CDefaultWeightingValue, FloatingLegAdjustedPeriodDates.Count - 1); FloatingLegYearFractions = GetFloatingLegYearFractions(); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableIRCap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="effectiveDate">The effective Date.</param> /// <param name="term">The cap term.</param> /// <param name="strike">The strike for each caplet.</param> /// <param name="lastResets">A list of reset rates. This may be null.</param> /// <param name="includeStubFlag">A flag: include the first stub periood or not.</param> /// <param name="paymentFrequency">The caplet frequency.</param> /// <param name="rollBackward">A flag which determines whether to roll /// the dates: Backward or Forward. Currency this is ignored.</param> /// <param name="resetOffset">The relative date offset for all the fixings.</param> /// <param name="paymentBusinessDayAdjustments">The payment business day adjustments.</param> /// <param name="capCalculation">The cap calculation.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="fixingCalendar"></param> public PriceableIRFloor(DateTime baseDate, DateTime effectiveDate, string term, Double strike, List <double> lastResets, Boolean includeStubFlag, string paymentFrequency, Boolean rollBackward, RelativeDateOffset resetOffset, BusinessDayAdjustments paymentBusinessDayAdjustments, Calculation capCalculation, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar) : base(baseDate, effectiveDate, term, strike, lastResets, includeStubFlag, paymentFrequency, rollBackward, resetOffset, paymentBusinessDayAdjustments, capCalculation, fixingCalendar, paymentCalendar) { IsCap = false; }