//------------------------------------------------------------------------- // rate calculation private static RateCalculation parseRateCalculation(CsvRow row, string leg, FloatingRateIndex index, DayCount defaultFixedLegDayCount, BusinessDayAdjustment bda, Currency currency) { if (index is IborIndex) { return(parseIborRateCalculation(row, leg, (IborIndex)index, bda, currency)); } else if (index is OvernightIndex) { Optional <FloatingRateName> frnOpt = FloatingRateName.extendedEnum().find(getValue(row, leg, INDEX_FIELD)); if (frnOpt.Present) { FloatingRateName frn = frnOpt.get(); if (frn.Type == FloatingRateType.OVERNIGHT_AVERAGED) { return(parseOvernightRateCalculation(row, leg, (OvernightIndex)index, OvernightAccrualMethod.AVERAGED)); } } return(parseOvernightRateCalculation(row, leg, (OvernightIndex)index, OvernightAccrualMethod.COMPOUNDED)); } else if (index is PriceIndex) { return(parseInflationRateCalculation(row, leg, (PriceIndex)index, currency)); } else { return(parseFixedRateCalculation(row, leg, currency, defaultFixedLegDayCount)); } }
//------------------------------------------------------------------------- // parse the index and default fixed leg day count private static FloatingRateIndex parseIndex(CsvRow row, string leg) { Optional <string> fixedRateOpt = findValue(row, leg, FIXED_RATE_FIELD); Optional <string> indexOpt = findValue(row, leg, INDEX_FIELD); if (fixedRateOpt.Present) { if (indexOpt.Present) { throw new System.ArgumentException("Swap leg must not define both '" + leg + FIXED_RATE_FIELD + "' and '" + leg + INDEX_FIELD + "'"); } return(null); } if (!indexOpt.Present) { throw new System.ArgumentException("Swap leg must define either '" + leg + FIXED_RATE_FIELD + "' or '" + leg + INDEX_FIELD + "'"); } // use FloatingRateName to identify Ibor vs other string indexStr = indexOpt.get(); FloatingRateName frn = FloatingRateName.parse(indexStr); if (frn.Type == FloatingRateType.IBOR) { // re-parse Ibor using tenor, which ensures tenor picked up from indexStr if present Frequency freq = Frequency.parse(getValue(row, leg, FREQUENCY_FIELD)); Tenor iborTenor = freq.Term ? frn.DefaultTenor : Tenor.of(freq.Period); return(FloatingRateIndex.parse(indexStr, iborTenor)); } return(frn.toFloatingRateIndex()); }
public static FloatingRateIndex Parse(string s) { var result = new FloatingRateIndex { Value = s }; return(result); }
public static FloatingRateIndex Parse(string s) { FloatingRateIndex result = new FloatingRateIndex(); result.Value = s; return(result); }
public static FloatingRateCalculation CreateFloating(FloatingRateIndex floatingRateIndex, Period tenor) { FloatingRateCalculation floatingRateCalculation = new FloatingRateCalculation(); floatingRateCalculation.floatingRateIndex = floatingRateIndex; floatingRateCalculation.indexTenor = tenor; return(floatingRateCalculation); }
public static FloatingRateCalculation CreateFloating(FloatingRateIndex floatingRateIndex, Period tenor) { var floatingRateCalculation = new FloatingRateCalculation { floatingRateIndex = floatingRateIndex, indexTenor = tenor }; return(floatingRateCalculation); }
public virtual void test_tryParse_withTenor() { assertEquals(FloatingRateIndex.tryParse("GBP-LIBOR", Tenor.TENOR_6M), IborIndices.GBP_LIBOR_6M); assertEquals(FloatingRateIndex.tryParse("GBP-LIBOR-1M", Tenor.TENOR_6M), IborIndices.GBP_LIBOR_1M); assertEquals(FloatingRateIndex.tryParse("GBP-LIBOR-3M", Tenor.TENOR_6M), IborIndices.GBP_LIBOR_3M); assertEquals(FloatingRateIndex.tryParse("GBP-SONIA", Tenor.TENOR_6M), OvernightIndices.GBP_SONIA); assertEquals(FloatingRateIndex.tryParse("GB-RPI", Tenor.TENOR_6M), PriceIndices.GB_RPI); assertEquals(FloatingRateIndex.tryParse(null, Tenor.TENOR_6M), null); assertEquals(FloatingRateIndex.tryParse("NotAnIndex", Tenor.TENOR_6M), null); }
// parse a single leg private static RateCalculationSwapLeg parseLeg(CsvRow row, string leg, FloatingRateIndex index, DayCount defaultFixedLegDayCount) { PayReceive payReceive = LoaderUtils.parsePayReceive(getValue(row, leg, DIRECTION_FIELD)); PeriodicSchedule accrualSch = parseAccrualSchedule(row, leg); PaymentSchedule paymentSch = parsePaymentSchedule(row, leg, accrualSch.Frequency); NotionalSchedule notionalSch = parseNotionalSchedule(row, leg); RateCalculation calc = parseRateCalculation(row, leg, index, defaultFixedLegDayCount, accrualSch.BusinessDayAdjustment, notionalSch.Currency); return(RateCalculationSwapLeg.builder().payReceive(payReceive).accrualSchedule(accrualSch).paymentSchedule(paymentSch).notionalSchedule(notionalSch).calculation(calc).build()); }
public virtual void test_parse_noTenor() { assertEquals(FloatingRateIndex.parse("GBP-LIBOR"), IborIndices.GBP_LIBOR_3M); assertEquals(FloatingRateIndex.parse("GBP-LIBOR-1M"), IborIndices.GBP_LIBOR_1M); assertEquals(FloatingRateIndex.parse("GBP-LIBOR-3M"), IborIndices.GBP_LIBOR_3M); assertEquals(FloatingRateIndex.parse("GBP-SONIA"), OvernightIndices.GBP_SONIA); assertEquals(FloatingRateIndex.parse("GB-RPI"), PriceIndices.GB_RPI); assertThrowsIllegalArg(() => FloatingRateIndex.parse(null)); assertThrowsIllegalArg(() => FloatingRateIndex.parse("NotAnIndex")); }
public static FloatingRateDefinition CreateSimple(FloatingRateIndex floatingRateIndex, Period tenor, decimal derivedRate, decimal spread) { FloatingRateDefinition floatingRateDefinition = new FloatingRateDefinition(); floatingRateDefinition.calculatedRate = derivedRate + spread; floatingRateDefinition.calculatedRateSpecified = true; floatingRateDefinition.spread = spread; floatingRateDefinition.spreadSpecified = true; return(floatingRateDefinition); }
public static FloatingRateDefinition CreateSimple(FloatingRateIndex floatingRateIndex, Period tenor, decimal derivedRate, decimal spread) { var floatingRateDefinition = new FloatingRateDefinition { calculatedRate = derivedRate + spread, calculatedRateSpecified = true, spread = spread, spreadSpecified = true }; return(floatingRateDefinition); }
public static Calculation CreateFloating(decimal fixedRate, Money notional, FloatingRateIndex floatingRateIndex, Period tenor, DayCountFraction dayCountFraction, DiscountingTypeEnum discountingType) { var calculation = new Calculation { Item = NotionalFactory.Create(notional), compoundingMethod = CompoundingMethodEnum.None, compoundingMethodSpecified = true, dayCountFraction = dayCountFraction, discounting = DiscountingHelper.Create(fixedRate, dayCountFraction, discountingType), Items = new object[] { FloatingRateCalculationHelper.CreateFloating(floatingRateIndex, tenor) } }; return(calculation); }
/// <summary> /// Parses from the CSV row. /// </summary> /// <param name="row"> the CSV row </param> /// <param name="info"> the trade info </param> /// <returns> the parsed trade </returns> internal static SwapTrade parse(CsvRow row, TradeInfo info) { // parse any number of legs by looking for 'Leg n Pay Receive' // this finds the index for each leg, using null for fixed legs IList <FloatingRateIndex> indices = new List <FloatingRateIndex>(); ISet <DayCount> dayCounts = new LinkedHashSet <DayCount>(); bool missingDayCount = false; string legPrefix = "Leg 1 "; Optional <string> payReceiveOpt = getValue(row, legPrefix, DIRECTION_FIELD); int i = 1; while (payReceiveOpt.Present) { // parse this leg, capturing the day count for floating legs FloatingRateIndex index = parseIndex(row, legPrefix); indices.Add(index); if (index != null) { dayCounts.Add(index.DefaultFixedLegDayCount); } // defaulting only triggered if a fixed leg actually has a missing day count if (index == null && !findValue(row, legPrefix, DAY_COUNT_FIELD).Present) { missingDayCount = true; } // check if there is another leg i++; legPrefix = "Leg " + i + " "; payReceiveOpt = findValue(row, legPrefix, DIRECTION_FIELD); } // determine the default day count for the fixed leg (only if there is a fixed leg) DayCount defaultFixedLegDayCount = null; if (missingDayCount) { if (dayCounts.Count != 1) { throw new System.ArgumentException("Invalid swap definition, day count must be defined on each fixed leg"); } defaultFixedLegDayCount = Iterables.getOnlyElement(dayCounts); } // parse fully now we know the number of legs and the default fixed leg day count IList <SwapLeg> legs = parseLegs(row, indices, defaultFixedLegDayCount); Swap swap = Swap.of(legs); return(SwapTrade.of(info, swap)); }
public static FloatingLegCalculation Create(FloatingRateIndex floatingRateIndex, Period tenor, AveragingMethodEnum averagingMethod, decimal conversionFactor, Rounding rounding, CommodityPricingDates pricingDates, CommodityFx fx, object[] commoditySpreadArray) { var floatingRateCalculation = new FloatingLegCalculation { averagingMethod = averagingMethod, averagingMethodSpecified = true, conversionFactor = conversionFactor, conversionFactorSpecified = true, rounding = rounding, pricingDates = pricingDates, fx = fx, Items = commoditySpreadArray }; return(floatingRateCalculation); }
public static FloatingRateDefinition CreateCapFloor(FloatingRateIndex floatingRateIndex, Period tenor, DateTime adjustedFixingDate, decimal observedRate, decimal spread, decimal capfloorstrike, bool isCap) { FloatingRateDefinition floatingRateDefinition = CreateSimple(floatingRateIndex, tenor, adjustedFixingDate, observedRate, spread); var strike = new Strike(); strike.strikeRate = capfloorstrike; if (isCap) { floatingRateDefinition.capRate = new[] { strike }; } else { floatingRateDefinition.floorRate = new[] { strike }; } return(floatingRateDefinition); }
public static Calculation CreateFloating(Money notional, FloatingRateIndex floatingRateIndex, Period tenor, DayCountFraction dayCountFraction, DiscountingTypeEnum?discountingType) { var discounting = discountingType != null ? DiscountingHelper.Create(null, dayCountFraction, (DiscountingTypeEnum)discountingType) : null; var calculation = new Calculation { Items = new object[] { NotionalFactory.Create(notional) }, compoundingMethod = CompoundingMethodEnum.None, compoundingMethodSpecified = true, dayCountFraction = dayCountFraction, discounting = discounting, Items1 = new object[] { FloatingRateCalculationHelper.CreateFloating(floatingRateIndex, tenor) } }; return(calculation); }
public static Calculation CreateFloating(Money notional, FloatingRateIndex floatingRateIndex, Period tenor, DayCountFraction dayCountFraction, DiscountingTypeEnum discountingType) { var calculation = new Calculation { Items = new object[] { NotionalFactory.Create(notional) }, compoundingMethod = CompoundingMethodEnum.None, compoundingMethodSpecified = true, dayCountFraction = dayCountFraction }; var discounting = new Discounting { discountingType = discountingType, discountRateDayCountFraction = dayCountFraction }; calculation.discounting = discounting; calculation.Items = new object[] { FloatingRateCalculationHelper.CreateFloating(floatingRateIndex, tenor) }; return(calculation); }
public static RateIndex Create(string instrumentId, FloatingRateIndex floatingRateIndex, Currency currency, DayCountFraction dayCountFraction, Period paymentFrequency, Period term) { RateIndex rateIndex = new RateIndex(); rateIndex.currency = new IdentifiedCurrency() { Value = currency.Value }; rateIndex.dayCountFraction = dayCountFraction; rateIndex.floatingRateIndex = floatingRateIndex; rateIndex.id = instrumentId; rateIndex.instrumentId = InstrumentIdArrayHelper.Parse(instrumentId); rateIndex.paymentFrequency = paymentFrequency; rateIndex.term = term; return(rateIndex); }
public static RateIndex Create(string instrumentId, FloatingRateIndex floatingRateIndex, Currency currency, DayCountFraction dayCountFraction, Period paymentFrequency, Period term) { var rateIndex = new RateIndex { currency = new IdentifiedCurrency { Value = currency.Value }, dayCountFraction = dayCountFraction, floatingRateIndex = floatingRateIndex, id = instrumentId, instrumentId = InstrumentIdArrayHelper.Parse(instrumentId), paymentFrequency = paymentFrequency, term = term }; return(rateIndex); }
///<summary> /// Gets all the Discount curve name. ///</summary> ///<returns></returns> public static string GetForecastCurveName(FloatingRateIndex floatingRateIndex, Period[] periods) { return(GetForecastCurveName(PricingStructureTypeEnum.RateCurve, floatingRateIndex, periods)); }
public static FloatingRateDefinition CreateSimple(FloatingRateIndex floatingRateIndex, Period tenor, DateTime adjustedFixingDate, decimal observedRate, decimal spread) { return(CreateSimple(adjustedFixingDate, observedRate, spread)); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> private static string GetForecastCurveName(PricingStructureTypeEnum curveType, FloatingRateIndex floatingRateIndex, Period[] periods) { return(curveType + "." + floatingRateIndex.Value + "-" + periods[0].ToString()); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> private static string GetForecastCurveName(PricingStructureTypeEnum curveType, FloatingRateIndex floatingRateIndex) { return(curveType + "." + floatingRateIndex.Value); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> public static string GetRateVolatilityMatrixName(FloatingRateIndex floatingRateIndex, Period indexTenor) { var result = GetRateVolatilityMatrixName(floatingRateIndex, new[] { indexTenor }); return(result); }
///<summary> /// Gets all the Forecast curve name. ///</summary> ///<returns></returns> public static string GetForecastCurveName(FloatingRateIndex floatingRateIndex, Period indexTenor) { string result = indexTenor != null?GetForecastCurveName(floatingRateIndex, new[] { indexTenor }) : GetForecastCurveName(PricingStructureTypeEnum.RateCurve, floatingRateIndex); return(result); }