public void TestTryParse_1y1m1q_Negative()
{
string tenor = "1y1m1q";
bool flag = Tenor.TryParse(tenor, out Tenor res);
Assert.IsFalse(flag);
}
public void TestTryParse_null_Negative()
{
string tenor = null;
bool flag = Tenor.TryParse(tenor, out Tenor res);
Assert.IsFalse(flag);
}
public void RateCurveCalibrator_CanCalibrateTwoCurves()
{
var instruments = new List <IRateCurveInstrument>();
var zarCsaCurveDescription = new DiscountingSourceDescription(_zar, new BankAccountNumeraire(_zar));
var jibarDiscountDescription = new DiscountingSourceDescription(_zar, _jibar3M);
instruments.Add(new DepoCurveInstrument(Tenor.FromMonths(3), 0.071, jibarDiscountDescription));
instruments.Add(new FixedFloatSwapCurveInstrument(Tenor.FromMonths(6), _jibar3M, 0.0, 0.07,
zarCsaCurveDescription, FixedFloatSwapCurveInstrument.CurveToStrip.Forecast));
instruments.Add(new FixedFloatSwapCurveInstrument(Tenor.FromYears(2), _jibar3M, 0.0, 0.07,
zarCsaCurveDescription, FixedFloatSwapCurveInstrument.CurveToStrip.Forecast));
instruments.Add(new DepoCurveInstrument(Tenor.FromDays(1), 0.06, zarCsaCurveDescription));
instruments.Add(new BasisSwapCurveInstrument(Tenor.FromYears(1), _jibar3M, _jibar1D, 0.0, 0.01,
zarCsaCurveDescription, BasisSwapCurveInstrument.CurveToStrip.DiscountCurve));
instruments.Add(new BasisSwapCurveInstrument(Tenor.FromYears(2), _jibar3M, _jibar1D, 0.0, 0.01,
zarCsaCurveDescription, BasisSwapCurveInstrument.CurveToStrip.DiscountCurve));
var calib = new RateCurveCalibrator(instruments, new MultiDimNewton(1e-8, 100),
zarCsaCurveDescription, new FloatRateIndex[] { _jibar1D },
jibarDiscountDescription, new FloatRateIndex[] { _jibar3M });
var mdc = new MarketDataContainer();
mdc.Set(calib);
calib.TryCalibrate(_calibrationDate, mdc);
var testValues = instruments.Select(inst => Math.Abs(inst.Objective()));
var maxTestValue = testValues.Max();
Assert.AreEqual(0.0, maxTestValue, 1e-8);
}
private static Pair <Tenor, Tenor> DeserializeKey(IFudgeField fudgeField)
{
Tenor first = DeserializeTenor(fudgeField, "first");
Tenor second = DeserializeTenor(fudgeField, "second");
return(new Pair <Tenor, Tenor>(first, second));
}
//-------------------------------------------------------------------------
// 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());
}
private void SetYSliceGraph(Tenor y)
{
var slice = Surface.GetYSlice(y);
_ySliceCurveControl.DataContext = slice;
leftCurveControl.DataContext = slice;
}
public void TestSwapHW()
{
// Make the swap
var rate = 0.08;
var payFixed = true;
double notional = 1000000;
var startDate = new Date(2016, 9, 17);
var tenor = Tenor.Years(5);
var swap = IRSwap.CreateZARSwap(rate, payFixed, notional, startDate, tenor);
// Set up the model
var valueDate = new Date(2016, 9, 17);
var a = 0.05;
var vol = 0.01;
var flatCurveRate = 0.07;
var hullWiteSim = new HullWhite1F(Currency.ZAR, a, vol, flatCurveRate, flatCurveRate, valueDate);
hullWiteSim.AddForecast(FloatingIndex.JIBAR3M);
var coordinator = new Coordinator(hullWiteSim, new List <Simulator>(), 10000);
// Run the valuation
var value = coordinator.Value(new Product[] { swap }, valueDate);
var refValue = -41838.32; // See RateProductTest.xlsx
Assert.AreEqual(refValue, value, 4000);
}
public void TestCoordinatorAllData()
{
// Make the swap
var rate = 0.07;
var payFixed = true;
double notional = 1000000;
var startDate = new Date(2016, 9, 17);
var tenor = Tenor.Years(5);
var swap = IRSwap.CreateZARSwap(rate, payFixed, notional, startDate, tenor);
// Set up the model
var valueDate = new Date(2016, 9, 17);
var a = 0.05;
var vol = 0.01;
var flatCurveRate = 0.07;
var hullWiteSim = new HullWhite1F(Currency.ZAR, a, vol, flatCurveRate, flatCurveRate, valueDate);
hullWiteSim.AddForecast(FloatingIndex.JIBAR3M);
var coordinator = new Coordinator(hullWiteSim, new List <Simulator>(), 5000);
var date = valueDate;
var endDate = valueDate.AddTenor(tenor);
var fwdValueDates = new List <Date>();
while (date < endDate)
{
fwdValueDates.Add(date);
date = date.AddTenor(Tenor.Days(10));
}
var allDetails = coordinator.GetValuePaths(new Product[] { swap }, valueDate, fwdValueDates.ToArray());
allDetails.GetNames();
}
private void SetXSliceGraph(Tenor x)
{
var slice = Surface.GetXSlice(x);
_xSliceCurveControl.DataContext = slice;
rightCurveControl.DataContext = slice;
}
public static object _CreateZARBermudanSwaption(string objectName,
object[,] exerciseDates,
object[,] longOptionality,
object[,] startDate,
object[,] tenor,
object[,] rate,
object[,] payFixed,
object[,] notional)
{
try
{
Date[] _exerciseDates = XU.GetDate1D(exerciseDates, "exerciseDates");
Boolean _longOptionality = XU.GetBoolean0D(longOptionality, "longOptionality");
Date _startDate = XU.GetDate0D(startDate, "startDate");
Tenor _tenor = XU.GetTenor0D(tenor, "tenor");
Double _rate = XU.GetDouble0D(rate, "rate");
Boolean _payFixed = XU.GetBoolean0D(payFixed, "payFixed");
Double _notional = XU.GetDouble0D(notional, "notional");
BermudanSwaption _result = XLRates.CreateZARBermudanSwaption(_exerciseDates, _longOptionality, _startDate, _tenor, _rate, _payFixed, _notional);
return(XU.AddObject(objectName, _result));
}
catch (Exception e)
{
return(XU.Error0D(e));
}
}
public FixedFloatSwapCurveInstrument(Tenor tenor, FloatRateIndex index, double spread, double fixedRate,
DiscountingSourceDescription discountCurveDescription, CurveToStrip curveToStrip)
{
_tenor = tenor;
_index = index;
_spread = spread;
_fixedRate = fixedRate;
_discountCurveDescription = discountCurveDescription;
switch (curveToStrip)
{
case CurveToStrip.Forecast:
{
_nameOfCurveToStrip = new FloatingRateSourceDescription(index).Name;
break;
}
case CurveToStrip.Discount:
{
_nameOfCurveToStrip = _discountCurveDescription.Name;
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(curveToStrip), curveToStrip, null);
}
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 102727412: // label
this.label_Renamed = (string)newValue;
break;
case -518800962: // observableId
this.observableId_Renamed = (ObservableId)newValue;
break;
case 110246592: // tenor
this.tenor_Renamed = (Tenor)newValue;
break;
case 746995843: // spotDateOffset
this.spotDateOffset_Renamed = (DaysAdjustment)newValue;
break;
case -1065319863: // businessDayAdjustment
this.businessDayAdjustment_Renamed = (BusinessDayAdjustment)newValue;
break;
case 1905311443: // dayCount
this.dayCount_Renamed = (DayCount)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
public PointRecipe(Guid instrumentId, Tenor tenor, DateLag dateLag, PriceType?priceType = null)
{
InstrumentId = instrumentId;
Tenor = tenor;
DateLag = dateLag;
PriceType = priceType;
}
/// <summary>
/// Converts an FpML tenor string to a {@code Tenor}.
/// </summary>
/// <param name="multiplier"> the multiplier </param>
/// <param name="unit"> the unit </param>
/// <returns> the tenor </returns>
/// <exception cref="IllegalArgumentException"> if the tenor is not known </exception>
public Tenor convertIndexTenor(string multiplier, string unit)
{
string periodStr = multiplier + unit;
Tenor tenor = TENOR_MAP[periodStr];
return(tenor != null ? tenor : Tenor.parse(periodStr));
}
private static IborIndex parseIborIndex(CsvRow row)
{
string name = row.getValue(NAME_FIELD);
Currency currency = Currency.parse(row.getValue(CURRENCY_FIELD));
bool active = bool.Parse(row.getValue(ACTIVE_FIELD));
DayCount dayCount = DayCount.of(row.getValue(DAY_COUNT_FIELD));
HolidayCalendarId fixingCal = HolidayCalendarId.of(row.getValue(FIXING_CALENDAR_FIELD));
int offsetDays = int.Parse(row.getValue(OFFSET_DAYS_FIELD));
HolidayCalendarId offsetCal = HolidayCalendarId.of(row.getValue(OFFSET_CALENDAR_FIELD));
HolidayCalendarId effectiveCal = HolidayCalendarId.of(row.getValue(EFFECTIVE_DATE_CALENDAR_FIELD));
Tenor tenor = Tenor.parse(row.getValue(TENOR_FIELD));
LocalTime time = LocalTime.parse(row.getValue(FIXING_TIME_FIELD), TIME_FORMAT);
ZoneId zoneId = ZoneId.of(row.getValue(FIXING_ZONE_FIELD));
DayCount fixedLegDayCount = DayCount.of(row.getValue(FIXED_LEG_DAY_COUNT));
// interpret CSV
DaysAdjustment fixingOffset = DaysAdjustment.ofBusinessDays(-offsetDays, offsetCal, BusinessDayAdjustment.of(PRECEDING, fixingCal)).normalized();
DaysAdjustment effectiveOffset = DaysAdjustment.ofBusinessDays(offsetDays, offsetCal, BusinessDayAdjustment.of(FOLLOWING, effectiveCal)).normalized();
// convention can be two different things
PeriodAdditionConvention periodAdditionConvention = PeriodAdditionConvention.extendedEnum().find(row.getField(TENOR_CONVENTION_FIELD)).orElse(PeriodAdditionConventions.NONE);
BusinessDayConvention tenorBusinessConvention = BusinessDayConvention.extendedEnum().find(row.getField(TENOR_CONVENTION_FIELD)).orElse(isEndOfMonth(periodAdditionConvention) ? MODIFIED_FOLLOWING : FOLLOWING);
BusinessDayAdjustment adj = BusinessDayAdjustment.of(tenorBusinessConvention, effectiveCal);
TenorAdjustment tenorAdjustment = TenorAdjustment.of(tenor, periodAdditionConvention, adj);
// build result
return(ImmutableIborIndex.builder().name(name).currency(currency).active(active).dayCount(dayCount).fixingCalendar(fixingCal).fixingDateOffset(fixingOffset).effectiveDateOffset(effectiveOffset).maturityDateOffset(tenorAdjustment).fixingTime(time).fixingZone(zoneId).defaultFixedLegDayCount(fixedLegDayCount).build());
}
public void TestTenor_7d_is_1w()
{
var tenor7d = new Tenor(0, 0, 0, 7);
var tenor1w = new Tenor(0, 0, 1, 0);
Assert.IsTrue(tenor1w == tenor7d);
}
public void TestTenor_Constructor_Negative4()
{
Assert.ThrowsException <ArgumentOutOfRangeException>(() =>
{
Tenor tenor = new Tenor(1, 1, 1, -1);
});
}
public void TestTenor_12m_is_1y()
{
var tenor12m = new Tenor(0, 12, 0, 0);
var tenor1y = new Tenor(1, 0, 0, 0);
Assert.IsTrue(tenor1y == tenor12m);
}
private TenorParameterMetadata(Tenor tenor, string label)
{
JodaBeanUtils.notNull(tenor, "tenor");
JodaBeanUtils.notEmpty(label, "label");
this.tenor = tenor;
this.label = label;
}
private FixedInflationSwapTemplate(Tenor tenor, FixedInflationSwapConvention convention)
{
JodaBeanUtils.notNull(tenor, "tenor");
JodaBeanUtils.notNull(convention, "convention");
this.tenor = tenor;
this.convention = convention;
}
private Product[] GetListOfSwaps()
{
int N = 50000;
Date anchorDate = new Date(2016, 11, 21);
double rate = 0.08;
bool payFixed = true;
double notional = 1000000;
double[,] swapDist = new double[, ] {
{ 0.171 }, { 0.148 }, { 0.101 }, { 0.094 }, { 0.108 }, { 0.056 }, { 0.041 }, { 0.049 }, { 0.047 }, { 0.056 }, { 0.013 }, { 0.013 }, { 0.010 }, { 0.011 }, { 0.011 }, { 0.004 }, { 0.003 }, { 0.005 }, { 0.007 }, { 0.006 }, { 0.004 }, { 0.004 }, { 0.007 }, { 0.005 }, { 0.006 }, { 0.006 }, { 0.003 }, { 0.003 }, { 0.002 }, { 0.005 }
};
IRandomNumberGenerator <double> generator1 = new ZigguratUniformGenerator(0, 1);
IRandomNumberGenerator <double> generator365 = new ZigguratUniformGenerator(1, 365);
double[,] cumSum = swapDist.CumulativeSum(1);
Product[] allSwaps = new Product[N];
for (int swapNum = 0; swapNum < N; swapNum++)
{
double x = generator1.Generate();
int years = 0;
while (years < cumSum.GetLength(0) && x > cumSum[years, 0])
{
years++;
}
int days = (int)Math.Round(generator365.Generate());
Date endDate = anchorDate.AddTenor(new Tenor(days, 0, 0, years));
Date startDate = endDate.AddTenor(Tenor.Years(-years - 1));
allSwaps[swapNum] = IRSwap.CreateZARSwap(rate, payFixed, notional, startDate, Tenor.Years(years + 1));
}
return(allSwaps);
}
internal static FixedIborSwapCurveNode fixedIborSwapNode(Tenor tenor, string id)
{
QuoteId quoteId = QuoteId.of(StandardId.of(TEST_SCHEME, id));
FixedIborSwapTemplate template = FixedIborSwapTemplate.of(Period.ZERO, tenor, SWAP_CONVENTION);
return(FixedIborSwapCurveNode.of(template, quoteId));
}
public void TestSwap()
{
// Make the swap
var rate = 0.08;
var payFixed = true;
double notional = 1000000;
var startDate = new Date(2016, 9, 17);
var tenor = Tenor.Years(5);
var swap = IRSwap.CreateZARSwap(rate, payFixed, notional, startDate, tenor);
// Set up the model
var valueDate = new Date(2016, 9, 17);
Date[] dates = { new Date(2016, 9, 17), new Date(2026, 9, 17) };
double[] rates = { 0.07, 0.07 };
IDiscountingSource discountCurve = new DatesAndRates(Currency.ZAR, valueDate, dates, rates);
IFloatingRateSource forecastCurve = new ForecastCurve(valueDate, FloatingIndex.JIBAR3M, dates, rates);
var curveSim = new DeterminsiticCurves(discountCurve);
curveSim.AddRateForecast(forecastCurve);
var coordinator = new Coordinator(curveSim, new List <Simulator>(), 1);
// Run the valuation
var value = coordinator.Value(new Product[] { swap }, valueDate);
var refValue = -41838.32; // See RateProductTest.xlsx
Assert.AreEqual(refValue, value, 0.01);
}
public FloatRateIndex(string objectName, Currency currency, string indexName, Tenor tenor)
{
Currency = currency;
_indexName = indexName;
Tenor = tenor;
_objectName = objectName;
}
public BasisSwapCurveInstrument(Tenor tenor, FloatRateIndex leg1Index, FloatRateIndex leg2Index,
double leg1Spread,
double leg2Spread, DiscountingSourceDescription discountCurveDescription, CurveToStrip curveToStrip)
{
_tenor = tenor;
_leg1Index = leg1Index;
_leg2Index = leg2Index;
_leg1Spread = leg1Spread;
_leg2Spread = leg2Spread;
_discountCurveDescription = discountCurveDescription;
switch (curveToStrip)
{
case CurveToStrip.Leg1Forecast:
{
_curveName = new FloatingRateSourceDescription(leg1Index).Name;
break;
}
case CurveToStrip.Leg2Forecast:
{
_curveName = new FloatingRateSourceDescription(leg2Index).Name;
break;
}
case CurveToStrip.DiscountCurve:
{
_curveName = _discountCurveDescription.Name;
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(curveToStrip), curveToStrip, null);
}
}
/// <summary>
/// Add extra dates to make sure that the minimum spacing is not too large to make the Monte Carlo errors bad.
/// <para/>
/// At this point the dates are all copied.
/// </summary>
public override void Prepare(Date anchorDate)
{
_anchorDate = anchorDate;
fM = date => _inputRate;
PM = date => Math.Exp(-_inputRate * (date - anchorDate) / 365.0);
double minStepSize = 20;
allDates.Insert(0, anchorDate);
allDates = allDates.Distinct().ToList();
allDates.Sort();
var newDates = new List <Date>();
newDates.Add(new Date(allDates[0]));
for (var i = 1; i < allDates.Count; i++)
{
var nSteps = (int)Math.Floor((allDates[i] - allDates[i - 1]) / minStepSize);
var days = (allDates[i] - allDates[i - 1]) / (nSteps + 1);
for (var j = 0; j < nSteps; j++)
{
newDates.Add(new Date(allDates[i - 1].AddTenor(Tenor.FromDays((j + 1) * days))));
}
newDates.Add(new Date(allDates[i]));
}
allDates = newDates;
allDatesDouble = allDates.Select(date => (double)date).ToArray();
}
private void presentValueSensitivityRawDataParallelSensitivity(SabrParametersSwaptionVolatilities sabrCalibrated, TenorRawOptionData dataRaw)
{
PointSensitivities points = LEG_PRICER.presentValueSensitivityModelParamsSabr(FLOOR_LEG, MULTICURVE, sabrCalibrated).build();
CurrencyParameterSensitivities sabrParametersSurfaceSensitivities = sabrCalibrated.parameterSensitivity(points);
CurrencyParameterSensitivity parallelSensitivitiesSurface = RDSC.parallelSensitivity(sabrParametersSurfaceSensitivities, sabrCalibrated);
DoubleArray sensitivityArray = parallelSensitivitiesSurface.Sensitivity;
double fdShift = 1.0E-6;
int surfacePointIndex = 0;
for (int loopexpiry = 0; loopexpiry < EXPIRIES.size(); loopexpiry++)
{
for (int looptenor = 0; looptenor < TENORS.size(); looptenor++)
{
Tenor tenor = TENORS.get(looptenor);
Pair <DoubleArray, DoubleArray> ds = dataRaw.getData(tenor).availableSmileAtExpiry(EXPIRIES.get(loopexpiry));
if (!ds.First.Empty)
{
double[] pv = new double[2]; // pv with shift up and down
for (int loopsign = 0; loopsign < 2; loopsign++)
{
TenorRawOptionData dataShifted = SabrSwaptionCalibratorSmileTestUtils.rawDataShiftSmile(TENORS, EXPIRIES, ValueType.SIMPLE_MONEYNESS, MONEYNESS, ValueType.NORMAL_VOLATILITY, DATA_ARRAY_FULL, looptenor, loopexpiry, (2 * loopsign - 1) * fdShift);
SabrParametersSwaptionVolatilities calibratedShifted = SABR_CALIBRATION.calibrateWithFixedBetaAndShift(DEFINITION, CALIBRATION_TIME, dataShifted, MULTICURVE, BETA_SURFACE, SHIFT_SABR_SURFACE);
pv[loopsign] = LEG_PRICER.presentValue(FLOOR_LEG, MULTICURVE, calibratedShifted).Amount;
}
double sensitivityFd = (pv[1] - pv[0]) / (2 * fdShift); // FD sensitivity computation
SabrSwaptionCalibratorSmileTestUtils.checkAcceptable(sensitivityFd, sensitivityArray.get(surfacePointIndex), 0.10, "Tenor/Expiry: " + TENORS.get(looptenor) + " / " + EXPIRIES.get(loopexpiry));
surfacePointIndex++;
}
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ImmutablePreBuild private static void preBuild(Builder builder)
private static void preBuild(Builder builder)
{
if (string.ReferenceEquals(builder.label_Renamed, null) && builder.template_Renamed != null)
{
builder.label_Renamed = Tenor.of(builder.template_Renamed.DepositPeriod).ToString();
}
}
/// <summary>
/// Get an array of <see cref="Tenor"/> from an excel range of strings.
/// </summary>
/// <remarks>
/// This is implemented in the Excel layer rather than in <see cref="Tenor"/> itself to make sure that users in the library don't use strings to construct things.
/// </remarks>
/// <param name="values"></param>
/// <param name="inputName">The name of the input in the Excel function so that sensible errors can be returned.</param>
/// <returns></returns>
public static Tenor[] GetTenor1D(object[,] values, string inputName)
{
if (values.GetLength(0) == 1 && values.GetLength(1) >= 1) // row of inputs
{
Tenor[] result = new Tenor[values.GetLength(1)];
for (int i = 0; i < values.GetLength(1); i++)
{
result[i] = GetTenor(values[0, i], inputName);
}
return(result);
}
else if (values.GetLength(0) >= 1 && values.GetLength(1) == 1) // column of inputs
{
Tenor[] result = new Tenor[values.GetLength(0)];
for (int i = 0; i < values.GetLength(0); i++)
{
result[i] = GetTenor(values[i, 0], inputName);
}
return(result);
}
else
{
throw new ArgumentException(inputName + " must be a single row or column of strings representing tenors.");
}
}
public void Init()
{
// Set up the model
valueDate = new Date(2016, 9, 17);
var a = 0.05;
var vol = 0.01;
var flatCurveRate = 0.07;
hullWiteSim = new HullWhite1F(Currency.ZAR, a, vol, flatCurveRate, flatCurveRate, valueDate);
hullWiteSim.AddForecast(FloatingIndex.JIBAR3M);
// Make the underlying swap
var rate = 0.07;
var payFixed = true;
double notional = 1000000;
var startDate = new Date(2016, 9, 17);
var tenor = Tenor.Years(5);
swapPay = IRSwap.CreateZARSwap(rate, payFixed, notional, startDate, tenor);
swapRec = IRSwap.CreateZARSwap(rate, !payFixed, notional, startDate, tenor);
// Full set of exercise dates
exDates = new List <Date>
{
new Date(2017, 9, 17),
new Date(2018, 9, 17),
new Date(2019, 9, 17),
new Date(2020, 9, 17)
};
}
private FixedIncomeStripWithSecurity(FixedIncomeStrip originalStrip, Tenor resolvedTenor, DateTimeOffset maturity, ExternalId securityIdentifier, ISecurity security)
{
_resolvedTenor = resolvedTenor;
_originalStrip = originalStrip;
_maturity = maturity;
_securityIdentifier = securityIdentifier;
_security = security;
}
public static FixedIncomeStripWithSecurity FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var originalstrip = deserializer.FromField<FixedIncomeStrip>(ffc.GetByName("strip"));
var resolvedTenor = new Tenor(ffc.GetString("resolvedTenor"));
DateTimeOffset maturity = GetDateTime(ffc.GetByName("maturity"));
ExternalId securityIdentifier = ExternalId.Parse(ffc.GetString("identifier"));
var security = deserializer.FromField<ISecurity>(ffc.GetByName("security"));
return new FixedIncomeStripWithSecurity(originalstrip,
resolvedTenor,
maturity,
securityIdentifier,
security
);
}
private void UpdateCellSelection(Tenor x, Tenor y)
{
InitTableData();
Func<Dictionary<string, object>, bool> rowPredicate = row => row["Length"].Equals(y);
Func<DataGridColumn, bool> columnPredicate = c => c.Header.Equals(x);
DataGridColumn myColumn = detailsList.Columns.Where(columnPredicate).First();
Dictionary<string, object> myRow = detailsList.Items.Cast<Dictionary<string, object>>().Where(rowPredicate).First();
detailsList.SelectedCells.Clear();
detailsList.SelectedCells.Add(new DataGridCellInfo(myRow, myColumn));
}
private static double GetScaledValue(Tenor t)
{
return Math.Log(t.TimeSpan.TotalDays);
}
static public RateIndex FindRateIndex(string currency, string indexTicker, out Tenor tenor)
{
//US0003M Index
tenor = null;
var indexes = Env.Current.StaticData.GetCurrencyRateIndexes(currency);
string[] tenors = new[] { "3M", "6M", "9M", "1Y" };
var ticker = indexTicker.ToLower();
foreach (var index in indexes)
{
foreach (var sten in tenors)
{
var ten = Tenor.Get(sten);
var qn = index.BuildQuoteName(ten);
if (qn.DefaultTicker.ToLower().Equals(ticker))
{
tenor = ten;
return index;
}
}
}
Logger.Error("@@@ Cannot find Rate Index " + currency + " " + indexTicker);
return null;
}
static public RateIndex FindRateIndex2(string currency, string indexName, string tenor, out Tenor tenorOut)
{
tenorOut = null;
var indexes = Env.Current.StaticData.GetCurrencyRateIndexes(currency);
foreach (var index in indexes)
{
var theIndexName = index.Name;
if(theIndexName.Equals(indexName) || theIndexName.Contains(indexName) || indexName.Contains(theIndexName))
{
var ten = Tenor.Get(tenor);
if (ten != null)
{
tenorOut = ten;
return index;
}
}
}
Logger.Error("@@@ Cannot find Rate Index " + currency + " " + indexName + " " + tenor);
return null;
}
private void SetXSliceGraph(Tenor x)
{
var slice = Surface.GetXSlice(x);
_xSliceCurveControl.DataContext = slice;
rightCurveControl.DataContext = slice;
}
private void SetYSliceGraph(Tenor y)
{
var slice = Surface.GetYSlice(y);
_ySliceCurveControl.DataContext = slice;
leftCurveControl.DataContext = slice;
}
public static Curve GetYSlice(this VolatilitySurfaceData<Tenor, Tenor> surface, Tenor y)
{
var values = surface.Xs.Select(
delegate(Tenor t) {
double value;
var have = surface.TryGet(t, y, out value);
return Tuple.Create(t.TimeSpan.TotalMilliseconds, have, value);
}).Where(t => t.Item2);
return new InterpolatedDoublesCurve(string.Format("Swap length {0}", y),
values.Select(t => t.Item1).ToArray(),
values.Select(t => t.Item3).ToArray()
);
}
public static Curve GetXSlice(this VolatilitySurfaceData<Tenor, Tenor> surface, Tenor x)
{
return new InterpolatedDoublesCurve(string.Format("Expiry {0}", x),
surface.Ys.Select(t => t.TimeSpan.TotalMilliseconds).ToArray(),
surface.Ys.Select(y => surface[x, y]).ToArray()
);
}
private void UpdateToolTip(Tenor x, Tenor y)
{
toolTipBox.Text = string.Format("{0},{1},{2}", x, y, Surface[x, y]);
toolTip.IsOpen = true;
}
