/// <summary> /// Initializes a new instance of the <see cref="PriceableIRCap"/> 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 PriceableIRCap(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, paymentBusinessDayAdjustments, resetOffset, capCalculation, null) { Id = identifier; SimpleIRCap = new SimpleIRSwap { dayCountFraction = capCalculation.dayCountFraction }; ResetRates = resets; RiskMaturityDate = rollDates[rollDates.Count - 1]; AdjustedPeriodDates = rollDates; AdjustedStartDate = AdjustedPeriodDates[0]; ExpiryDates = GetResetDates(AdjustedPeriodDates, fixingCalendar, resetOffset, true); OptionsExpiryDate = ExpiryDates[ExpiryDates.Count - 1]; IsCap = true; Strikes = strikes; Notionals = notionals; YearFractions = GetYearFractions(); if (DiscountingType != null) { ModelIdentifier = "DiscountCapAsset"; } }
/// <summary> /// Initializes a new instance of the <see cref="PriceableIRSwap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="simpleIRSwap">This contains the minimal information for the swap.</param> /// <param name="spotDateOffset">All necessary data related to the spot period for the swap type.</param> /// <param name="calculation">Contians information related to the floating leg.</param> /// <param name="businessDayAdjustments">The business day adjustments for all payments.</param> /// <param name="underlyingRateIndex">Index of the floating leg.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> /// <param name="fixedRate">The fixed rate.</param> public PriceableIRSwap(DateTime baseDate, SimpleIRSwap simpleIRSwap, RelativeDateOffset spotDateOffset, Calculation calculation, BusinessDayAdjustments businessDayAdjustments, RateIndex underlyingRateIndex, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate) : base(baseDate, simpleIRSwap, spotDateOffset, calculation, businessDayAdjustments, underlyingRateIndex, 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="PriceableIRSwap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="fixedLegSwap">The fixed leg details.</param> /// <param name="spotDate">the spot date.</param> /// <param name="notional">The notional amount.</param> /// <param name="paymentBusinessDayAdjustments">The business day adjustments.</param> /// <param name="floatingLegSwap">The floating leg details.</param> /// <param name="floatingLegcalculation">The floatingLegcalculation.</param> /// <param name="fixingDateOffset">The fixing date business day adjustments.</param> /// <param name="resetRates">The reset rates of the floating leg - if any.</param> /// <param name="fixingCalendar">The fixing calendar. If null, a new is constructed based on the business calendars.</param> /// <param name="paymentCalendar">The payment calendar. If null, a new is constructed based on the business calendars.</param> /// <param name="fixedRate">The fixed rate.</param> /// <param name="spread">The spread on the floating leg.</param> public PriceableIRSwap(DateTime baseDate, SimpleIRSwap fixedLegSwap, DateTime spotDate, MoneyBase notional, BusinessDayAdjustments paymentBusinessDayAdjustments, SimpleIRSwap floatingLegSwap, Calculation floatingLegcalculation, RelativeDateOffset fixingDateOffset, List <Decimal> resetRates, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate, BasicQuotation spread) : base(baseDate, fixedLegSwap, fixingDateOffset, floatingLegcalculation, paymentBusinessDayAdjustments, null, fixingCalendar, paymentCalendar, fixedRate) { ModelIdentifier = DiscountingType == null ? "SwapAsset" : "DiscountSwapAsset"; FloatingLegSpread = GetSpread(spread); ForwardRates = resetRates?.ToArray(); UnderlyingRateIndex = RateIndexHelper.Parse(FloatingRateCalculation.floatingRateIndex.Value, notional.currency.Value, Calculation.dayCountFraction.Value); var unadjustedFloatingDates = DateScheduler.GetUnadjustedDateSchedule(spotDate, floatingLegSwap.term, floatingLegSwap.paymentFrequency); FloatingLegAdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(unadjustedFloatingDates, paymentBusinessDayAdjustments.businessDayConvention, paymentCalendar); FloatingLegWeightings = CreateWeightings(CDefaultWeightingValue, FloatingLegAdjustedPeriodDates.Count - 1); FloatingLegYearFractions = GetFloatingLegYearFractions(); }
private static UnderlyingAsset CreateSimpleIRSwap(string marketInstrumentId) { var simpleIRSwap = new SimpleIRSwap(); string[] slicedInstrumentId = marketInstrumentId.Split('-'); string instrumentCurrency = slicedInstrumentId[0]; string instrumentTerm = slicedInstrumentId[2]; simpleIRSwap.currency = new IdentifiedCurrency { Value = instrumentCurrency }; simpleIRSwap.term = PeriodHelper.Parse(instrumentTerm); simpleIRSwap.instrumentId = new[] { new InstrumentId() }; simpleIRSwap.instrumentId[0].Value = marketInstrumentId; return(simpleIRSwap); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleIRSwap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="identifier">The asset identifier.</param> /// <param name="adjustedDates">The dates.</param> /// <param name="notionalWeights">The notionals, weighted by the first notional.</param> /// <param name="calculation">A calculation.</param> /// <param name="businessDayAdjustments">The business day adjustments.</param> /// <param name="underlyingRateIndex">Index of the rate.</param> /// <param name="fixedRate">The fixed rate.</param> public PriceableSimpleIRSwap(DateTime baseDate, string identifier, DateTime[] adjustedDates, Decimal[] notionalWeights, Calculation calculation, BusinessDayAdjustments businessDayAdjustments, RateIndex underlyingRateIndex, BasicQuotation fixedRate) : base(baseDate, businessDayAdjustments, calculation, fixedRate) { Id = identifier; SimpleIRSwap = new SimpleIRSwap { dayCountFraction = calculation.dayCountFraction }; UnderlyingRateIndex = underlyingRateIndex; RiskMaturityDate = adjustedDates[adjustedDates.Length - 1]; AdjustedPeriodDates = new List <DateTime>(adjustedDates); AdjustedStartDate = AdjustedPeriodDates[0]; Weightings = notionalWeights; YearFractions = GetYearFractions(); ModelIdentifier = DiscountingType == null ? "SimpleSwapAsset" : "SimpleDiscountSwapAsset"; var timeToMaturity = Actual365.Instance.YearFraction(baseDate, RiskMaturityDate); EndDiscountFactor = (decimal)System.Math.Exp(-(double)fixedRate.value * timeToMaturity); }
/// <summary> /// Initializes a new instance of the <see cref="PriceableSimpleIRSwap"/> class. /// </summary> /// <param name="baseDate">The base date.</param> /// <param name="simpleIRSwap">THe FpML swap.</param> /// <param name="spotDate">The spot date.</param> /// <param name="calculation">A calculation.</param> /// <param name="stringRollConvention">The roll convention.</param> /// <param name="businessDayAdjustments">The business day adjustments.</param> /// <param name="underlyingRateIndex">Index of the rate.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="paymentCalendar">The paymentCalendar.</param> /// <param name="fixedRate">The fixed rate.</param> public PriceableSimpleIRSwap(DateTime baseDate, SimpleIRSwap simpleIRSwap, DateTime spotDate, Calculation calculation, String stringRollConvention, BusinessDayAdjustments businessDayAdjustments, RateIndex underlyingRateIndex, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicQuotation fixedRate) : base(baseDate, businessDayAdjustments, calculation, fixedRate) { Id = simpleIRSwap.id; SimpleIRSwap = simpleIRSwap; UnderlyingRateIndex = underlyingRateIndex; AdjustedStartDate = spotDate; List <DateTime> unadjustedDateSchedule = DateScheduler.GetUnadjustedDateSchedule(AdjustedStartDate, SimpleIRSwap.term, SimpleIRSwap.paymentFrequency); AdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(unadjustedDateSchedule, BusinessDayAdjustments.businessDayConvention, paymentCalendar); RiskMaturityDate = AdjustedPeriodDates[AdjustedPeriodDates.Count - 1]; Weightings = CreateWeightings(CDefaultWeightingValue, AdjustedPeriodDates.Count - 1); YearFractions = GetYearFractions(); ModelIdentifier = DiscountingType == null ? "SimpleSwapAsset" : "SimpleDiscountSwapAsset"; var timeToMaturity = Actual365.Instance.YearFraction(baseDate, RiskMaturityDate); EndDiscountFactor = (decimal)System.Math.Exp(-(double)fixedRate.value * timeToMaturity); }
/// <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 period 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="fixingCalendar">The fixing Calendar.</param> /// <param name="paymentCalendar">The payment Calendar.</param> /// <param name="capCalculation">The cap calculation.</param> public PriceableIRCap(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, paymentBusinessDayAdjustments, resetOffset, capCalculation, null) { Id = "Local"; SimpleIRCap = new SimpleIRSwap { dayCountFraction = capCalculation.dayCountFraction }; ResetRates = lastResets; var unadjustedDates = Analytics.Schedulers.DateScheduler.GetUnadjustedDateSchedule(effectiveDate, PeriodHelper.Parse(term), PeriodHelper.Parse(paymentFrequency)); var adjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(unadjustedDates, paymentBusinessDayAdjustments.businessDayConvention, paymentCalendar); RiskMaturityDate = adjustedPeriodDates[adjustedPeriodDates.Count - 1]; IncludeFirstPeriod = includeStubFlag; //if (!includeStubFlag) //{ // adjustedPeriodDates.RemoveAt(0); //} AdjustedStartDate = effectiveDate; AdjustedPeriodDates = adjustedPeriodDates; ExpiryDates = GetResetDates(AdjustedPeriodDates, fixingCalendar, resetOffset, true); OptionsExpiryDate = ExpiryDates[ExpiryDates.Count - 1]; IsCap = true; YearFractions = GetYearFractions(); Strikes = CreateList(strike, YearFractions.Count); Notionals = CreateList((double)InitialNotional, YearFractions.Count); if (DiscountingType != null) { ModelIdentifier = "DiscountCapAsset"; } }
/// <summary> /// Parses the data. /// </summary> /// <param name="instrumentIds"></param> /// <returns></returns> public static QuotedAssetSet Parse(string[] instrumentIds) { var quotedAssetSetFactory = new QuotedAssetSetFactory(); const string rateQuotationType = "MarketQuote"; for (var i = 0; i < instrumentIds.Length; i++) { Asset underlyingAsset; var instrumentId = instrumentIds[i]; var results = instrumentIds[i].Split('-'); var instrument = results[1]; var listBasicQuotations = new List <BasicQuotation>(); const string priceUnitDecimalRate = "DecimalRate"; switch (instrument) { case "ZeroRate": { underlyingAsset = new Cash { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "Xibor": case "OIS": { var tenor = results[2]; underlyingAsset = new RateIndex { id = instrumentId, term = Period.Parse(tenor) }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "IRSwap": case "XccySwap": case "SimpleIRSwap": { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = Period.Parse(results[2]) }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "Deposit": case "XccyDepo": case "BankBill": { underlyingAsset = new Deposit { id = instrumentId, term = Period.Parse(results[2]) }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "SimpleFra": case "Fra": case "BillFra": { var index = results[3]; var asset = new SimpleFra { id = instrumentId, startTerm = Period.Parse(results[2]) }; asset.endTerm = asset.startTerm.Sum(Period.Parse(index)); underlyingAsset = asset; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "IRFuture": { underlyingAsset = new Future { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); listBasicQuotations.Add(BasicQuotationHelper.Create("Volatility", "LognormalVolatility")); break; } case "CPIndex": { var tenor = results[2]; underlyingAsset = new RateIndex { id = instrumentId, term = Period.Parse(tenor) }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } case "SimpleCPISwap": case "CPISwap": case "ZCCPISwap": { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = Period.Parse(results[2]) }; listBasicQuotations.Add(BasicQuotationHelper.Create(rateQuotationType, priceUnitDecimalRate)); break; } default: throw new NotSupportedException(string.Format("Asset type {0} is not supported", instrument)); } quotedAssetSetFactory.AddAssetAndQuotes(underlyingAsset, Helpers.BasicAssetValuationHelper.Create(underlyingAsset.id, listBasicQuotations.ToArray())); } return(quotedAssetSetFactory.Create()); }
/// <summary> /// Parses the string info into an asset. /// </summary> /// <param name="instrumentId"></param> /// <param name="value"></param> /// <param name="adjustment"></param> /// <returns></returns> public static Pair <Asset, BasicAssetValuation> Parse(string instrumentId, decimal value, decimal adjustment) { const string rateQuotationType = "MarketQuote"; Asset underlyingAsset; var results = instrumentId.Split('-'); var instrument = results[1]; var listBasicQuotations = new List <BasicQuotation>(); switch (instrument) { case "ZeroRate": { var zeroRate = new Cash { id = instrumentId }; underlyingAsset = zeroRate; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); break; } case "Xibor": case "OIS": { var tenor = results[2]; var rateIndex = new RateIndex { id = instrumentId, term = Period.Parse(tenor) }; underlyingAsset = rateIndex; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "IRSwap": case "XccySwap": case "SimpleIRSwap": { var simpleIRSwap = new SimpleIRSwap { id = instrumentId, term = Period.Parse(results[2]) }; underlyingAsset = simpleIRSwap; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "Deposit": case "XccyDepo": case "BankBill": { var deposit = new Deposit { id = instrumentId, term = Period.Parse(results[2]) }; underlyingAsset = deposit; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "SimpleFra": case "Fra": case "BillFra": case "SpreadFra": { var index = results[3]; var asset = new SimpleFra { id = instrumentId, startTerm = Period.Parse(results[2]) }; asset.endTerm = asset.startTerm.Sum(Period.Parse(index)); underlyingAsset = asset; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "IRCap": { var simpleIRCap = new SimpleIRSwap { id = instrumentId, term = Period.Parse(results[2]) }; underlyingAsset = simpleIRCap; listBasicQuotations.Add(BasicQuotationHelper.Create(value, "Premium", "Amount")); break; } case "IRFuture": { var future = new Future { id = instrumentId }; underlyingAsset = future; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); listBasicQuotations.Add(BasicQuotationHelper.Create(adjustment, "Volatility", "LognormalVolatility")); break; } case "CommodityFuture": { var future = new Future { id = instrumentId }; underlyingAsset = future; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); break; } case "CPIndex": { var tenor = results[2]; var rateIndex = new RateIndex { id = instrumentId, term = Period.Parse(tenor) }; underlyingAsset = rateIndex; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "SimpleCPISwap": case "CPISwap": case "ZCCPISwap": { var simpleIRSwap = new SimpleIRSwap { id = instrumentId, term = Period.Parse(results[2]) }; underlyingAsset = simpleIRSwap; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "DecimalRate")); break; } case "FxSpot": case "FxForward": { // var tenor = results[2]; var fxRateAsset = new FxRateAsset { id = instrumentId }; underlyingAsset = fxRateAsset; listBasicQuotations.Add(BasicQuotationHelper.Create(value + adjustment, rateQuotationType, "FxRate")); break; } case "CommoditySpot": case "CommodityForward": { var commodityAsset = new FxRateAsset { id = instrumentId }; underlyingAsset = commodityAsset; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "Price")); break; } case "Bond": { var asset = new Bond { id = instrumentId }; underlyingAsset = asset; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DirtyPrice")); break; } default: throw new NotSupportedException(string.Format("Asset type {0} is not supported", instrument)); } return(new Pair <Asset, BasicAssetValuation>(underlyingAsset, Helpers.BasicAssetValuationHelper.Create(underlyingAsset.id, listBasicQuotations.ToArray()))); }
/// <summary> /// Parses the string info into an asset. /// </summary> /// <param name="instrumentId"></param> /// <param name="value"></param> /// <param name="adjustment"></param> /// <returns></returns> public static Pair <Asset, BasicAssetValuation> Parse(string instrumentId, decimal value, decimal?adjustment) { const string rateQuotationType = PriceableSimpleRateAsset.RateQuotationType; const string volatilityQuotationType = PriceableCapRateAsset.VolatilityQuotationType; Asset underlyingAsset; decimal additional = 0.0m; if (adjustment != null) { additional = (decimal)adjustment; } var listBasicQuotations = new List <BasicQuotation>(); var properties = new PriceableAssetProperties(instrumentId); switch (properties.AssetType) { //This is in place to handle volatility curves where the tenor is the expiry. case AssetTypesEnum.Period: { //There is no underlying asset. underlyingAsset = null; listBasicQuotations.Add(BasicQuotationHelper.Create(instrumentId, value, volatilityQuotationType, "LognormalVolatility")); break; } case AssetTypesEnum.ZeroRate: { underlyingAsset = new Cash { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.Xibor: case AssetTypesEnum.OIS: { underlyingAsset = new RateIndex { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.IRSwap: case AssetTypesEnum.ClearedIRSwap: case AssetTypesEnum.OISSwap: case AssetTypesEnum.XccySwap: case AssetTypesEnum.SimpleIRSwap: case AssetTypesEnum.XccyBasisSwap: case AssetTypesEnum.BasisSwap: case AssetTypesEnum.ResettableXccyBasisSwap: { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.Caplet: case AssetTypesEnum.Floorlet: case AssetTypesEnum.BillCaplet: case AssetTypesEnum.BillFloorlet: { underlyingAsset = new SimpleFra { id = instrumentId, startTerm = properties.TermTenor, endTerm = properties.TermTenor.Sum(properties.ForwardIndex) }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, volatilityQuotationType, "LognormalVolatility")); if (adjustment != null) { listBasicQuotations.Add(BasicQuotationHelper.Create(additional, "Strike", "DecimalRate")); } break; } case AssetTypesEnum.Deposit: case AssetTypesEnum.SpreadDeposit: case AssetTypesEnum.XccyDepo: case AssetTypesEnum.BankBill: case AssetTypesEnum.Repo: case AssetTypesEnum.RepoSpread: { underlyingAsset = new Deposit { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.SimpleFra: case AssetTypesEnum.Fra: case AssetTypesEnum.BillFra: case AssetTypesEnum.SpreadFra: { underlyingAsset = new SimpleFra { id = instrumentId, startTerm = properties.TermTenor, endTerm = properties.TermTenor.Sum(properties.ForwardIndex) //TODO this restricts the perios to be the same!!! }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.Swaption: { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, volatilityQuotationType, "LognormalVolatility")); if (adjustment != null) { listBasicQuotations.Add(BasicQuotationHelper.Create(additional, "Strike", "DecimalRate")); } break; } case AssetTypesEnum.IRFloor: case AssetTypesEnum.IRCap: { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, volatilityQuotationType, "LognormalVolatility")); if (adjustment != null) { listBasicQuotations.Add(BasicQuotationHelper.Create(additional, "Strike", "DecimalRate")); } break; } case AssetTypesEnum.IRFutureOption: case AssetTypesEnum.IRCallFutureOption: case AssetTypesEnum.IRPutFutureOption: { underlyingAsset = new Future { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, volatilityQuotationType, "LognormalVolatility")); if (adjustment != null) { listBasicQuotations.Add(BasicQuotationHelper.Create(additional, "Strike", "DecimalRate")); } break; } case AssetTypesEnum.IRFuture: { underlyingAsset = new Future { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); if (adjustment != null) { listBasicQuotations.Add(BasicQuotationHelper.Create(additional, "Volatility", "LognormalVolatility")); } break; } case AssetTypesEnum.CommodityFuture: case AssetTypesEnum.CommodityFutureSpread: { underlyingAsset = new Future { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.CPIndex: { underlyingAsset = new RateIndex { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.SimpleCPISwap: case AssetTypesEnum.CPISwap: case AssetTypesEnum.ZCCPISwap: { underlyingAsset = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "DecimalRate")); break; } case AssetTypesEnum.FxSpot: case AssetTypesEnum.FxForward: { underlyingAsset = new FxRateAsset { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "FxRate")); break; } case AssetTypesEnum.Equity: case AssetTypesEnum.EquityForward: { underlyingAsset = new EquityAsset { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "Price")); break; } case AssetTypesEnum.CommoditySpot: case AssetTypesEnum.CommodityForward: case AssetTypesEnum.CommodityAverageForward: case AssetTypesEnum.CommoditySpread: { underlyingAsset = new Commodity { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "Price")); break; } case AssetTypesEnum.Bond: case AssetTypesEnum.BondSpot: case AssetTypesEnum.BondForward: { underlyingAsset = new Bond { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value, rateQuotationType, "DecimalRate")); //Changed from DirtyPrice. break; } case AssetTypesEnum.Lease: { underlyingAsset = new Lease { id = instrumentId }; listBasicQuotations.Add(BasicQuotationHelper.Create(value + additional, rateQuotationType, "Price")); break; } default: throw new NotSupportedException($"Asset type {properties.AssetType} is not supported"); } var id = underlyingAsset?.id; if (underlyingAsset == null) { id = listBasicQuotations[0].id; } return(new Pair <Asset, BasicAssetValuation>(underlyingAsset, BasicAssetValuationHelper.Create(id, listBasicQuotations.ToArray()))); }
/// <summary> /// Parses the string info into an asset. /// </summary> /// <param name="instrumentId"></param> /// <returns></returns> public static Asset Parse(string instrumentId) { Asset underlyingAsset; var properties = new PriceableAssetProperties(instrumentId); switch (properties.AssetType) { case AssetTypesEnum.ZeroRate: { var zeroRate = new Cash { id = instrumentId }; underlyingAsset = zeroRate; break; } case AssetTypesEnum.Xibor: case AssetTypesEnum.OIS: { var rateIndex = new RateIndex { id = instrumentId, term = properties.TermTenor }; underlyingAsset = rateIndex; break; } case AssetTypesEnum.IRSwap: case AssetTypesEnum.ClearedIRSwap: case AssetTypesEnum.OISSwap: case AssetTypesEnum.XccySwap: case AssetTypesEnum.SimpleIRSwap: case AssetTypesEnum.XccyBasisSwap: case AssetTypesEnum.BasisSwap: case AssetTypesEnum.ResettableXccyBasisSwap: { var simpleIRSwap = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; underlyingAsset = simpleIRSwap; break; } case AssetTypesEnum.Deposit: case AssetTypesEnum.SpreadDeposit: case AssetTypesEnum.XccyDepo: case AssetTypesEnum.BankBill: case AssetTypesEnum.Repo: case AssetTypesEnum.RepoSpread: { var deposit = new Deposit { id = instrumentId, term = properties.TermTenor }; underlyingAsset = deposit; break; } case AssetTypesEnum.SimpleFra: case AssetTypesEnum.Fra: case AssetTypesEnum.BillFra: case AssetTypesEnum.SpreadFra: { var simpleFra = new SimpleFra { id = instrumentId, startTerm = properties.TermTenor }; if (properties.ForwardIndex == null) { throw new ArgumentException("ForwardIndex must be set in the instrumentId " + instrumentId, nameof(instrumentId)); } simpleFra.endTerm = simpleFra.startTerm.Sum(properties.ForwardIndex); underlyingAsset = simpleFra; break; } case AssetTypesEnum.IRFloor: case AssetTypesEnum.IRCap: { var simpleIRCap = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; underlyingAsset = simpleIRCap; break; } case AssetTypesEnum.IRFutureOption: case AssetTypesEnum.IRFuture: { var future = new Future { id = instrumentId }; underlyingAsset = future; break; } case AssetTypesEnum.CommodityFuture: case AssetTypesEnum.CommodityFutureSpread: { var future = new Future { id = instrumentId }; underlyingAsset = future; break; } case AssetTypesEnum.CPIndex: { var rateIndex = new RateIndex { id = instrumentId, term = properties.TermTenor }; underlyingAsset = rateIndex; break; } case AssetTypesEnum.SimpleCPISwap: case AssetTypesEnum.CPISwap: case AssetTypesEnum.ZCCPISwap: { var simpleIRSwap = new SimpleIRSwap { id = instrumentId, term = properties.TermTenor }; underlyingAsset = simpleIRSwap; break; } case AssetTypesEnum.Equity: case AssetTypesEnum.EquityForward: { // var tenor = results[2]; var equityAsset = new EquityAsset { id = instrumentId }; underlyingAsset = equityAsset; break; } case AssetTypesEnum.FxSpot: case AssetTypesEnum.FxForward: { // var tenor = results[2]; var fxRateAsset = new FxRateAsset { id = instrumentId }; underlyingAsset = fxRateAsset; break; } case AssetTypesEnum.CommoditySpot: case AssetTypesEnum.CommodityForward: case AssetTypesEnum.CommodityAverageForward: case AssetTypesEnum.CommoditySpread: { var commodityAsset = new Commodity { id = instrumentId }; underlyingAsset = commodityAsset; break; } case AssetTypesEnum.Bond: case AssetTypesEnum.BondSpot: case AssetTypesEnum.BondForward: { var bond = new Bond { id = instrumentId }; underlyingAsset = bond; break; } default: throw new NotSupportedException($"Asset type {properties.AssetType} is not supported"); } return(underlyingAsset); }