public void CompositePriceCurveFact()
{
var originDate = new DateTime(2019, 05, 28);
var zar = TestProviderHelper.CurrencyProvider.GetCurrency("ZAR");
var usd = TestProviderHelper.CurrencyProvider.GetCurrency("USD");
var zarCurve = new ConstantRateIrCurve(0.07, originDate, "ZARCurve", zar);
var usdCurve = new ConstantRateIrCurve(0.02, originDate, "USDCurve", usd);
var fModel = new FundingModel(originDate, new[] { zarCurve, usdCurve }, TestProviderHelper.CurrencyProvider, TestProviderHelper.CalendarProvider);
var fxMatrix = new FxMatrix(TestProviderHelper.CurrencyProvider);
var fxPair = new FxPair {
Domestic = zar, Foreign = usd, SpotLag = new Dates.Frequency("0d")
};
fxMatrix.Init(zar, originDate, new Dictionary <Currency, double> {
{ usd, 10.0 }
}, new List <FxPair>()
{
fxPair
}, new Dictionary <Currency, string> {
{ usd, "USDCurve" }, { zar, "ZARCurve" }
});
fModel.SetupFx(fxMatrix);
var baseCurve = new ConstantPriceCurve(100.0, originDate, TestProviderHelper.CurrencyProvider)
{
Currency = usd,
Name = "gooo",
AssetId = "rooo"
};
var sut = new CompositePriceCurve(originDate, baseCurve, fModel, zar);
var sut2 = new CompositePriceCurve(originDate, () => baseCurve, () => fModel, zar);
var fxOrigin = fModel.GetFxRate(originDate, usd, zar);
Assert.Equal(baseCurve.GetPriceForDate(originDate) * fxOrigin, sut.GetPriceForDate(originDate));
Assert.Equal(baseCurve.GetPriceForDate(originDate) * fxOrigin, sut2.GetPriceForDate(originDate));
Assert.Equal(baseCurve.GetPriceForDate(originDate) * fxOrigin, sut.GetPriceForFixingDate(originDate));
Assert.Equal(baseCurve.GetPriceForDate(originDate) * fxOrigin, sut.GetAveragePriceForDates(new[] { originDate }));
Assert.Equal("gooo", sut.Name);
Assert.Throws <Exception>(() => sut.Name = null);
Assert.Single(sut.GetDeltaScenarios(0.0, null));
Assert.Equal(PriceCurveType.Linear, sut.CurveType);
Assert.False(sut.UnderlyingsAreForwards);
Assert.Equal(1, sut.NumberOfPillars);
Assert.Equal("rooo", sut.AssetId);
Assert.Equal(zar, sut.CompoCurrency);
Assert.Equal(zar, sut.Currency);
Assert.Throws <Exception>(() => sut.Currency = null);
Assert.Equal(usd, sut.CurveCurrency);
Assert.Single(sut.PillarDates);
Assert.Equal(DateTime.Today.AddDays(1), sut.RebaseDate(DateTime.Today.AddDays(1)).BuildDate);
Assert.Equal(originDate, sut.PillarDatesForLabel(originDate.ToString("yyyy-MM-dd")));
Assert.Throws <Exception>(() => sut.PillarDatesForLabel(""));
}
public void HazzardCurveFact()
{
var hzi = new Math.Interpolation.ConstantHazzardInterpolator(0.1);
var origin = new DateTime(2019, 05, 28);
var hz = new HazzardCurve(origin, Dates.DayCountBasis.Act365F, hzi);
Assert.Equal(1.0, hz.GetSurvivalProbability(origin, origin));
Assert.Equal(1.0, hz.GetSurvivalProbability(origin));
Assert.Equal(hzi.Interpolate(1.0 / 365.0), hz.GetSurvivalProbability(origin, origin.AddDays(1)));
var dfCurve = new ConstantRateIrCurve(0.05, origin, "zzz", TestProviderHelper.CurrencyProvider.GetCurrency("USD"));
var df = dfCurve.GetDf(origin, origin.AddDays(100));
Assert.Equal(df, hz.RiskyDiscountFactor(origin, origin.AddDays(100), dfCurve, 0.0));
Assert.Equal(df * (1.0 - (1.0 - hzi.Interpolate(100.0 / 365)) * 0.5), hz.RiskyDiscountFactor(origin, origin.AddDays(100), dfCurve, 0.5));
}
private AssetFxModel GetModel()
{
var irCurveZar = new ConstantRateIrCurve(0.07, ValDate, "ZAR-IR", zar);
var irCurveUsd = new ConstantRateIrCurve(0.02, ValDate, "USD-IR", zar);
var fxMatrix = new FxMatrix(TestProviderHelper.CurrencyProvider);
var fxPair = new FxPair()
{
Domestic = usd,
Foreign = zar,
PrimaryCalendar = TestProviderHelper.CalendarProvider.GetCalendar("ZAR"),
SecondaryCalendar = TestProviderHelper.CalendarProvider.GetCalendar("USD"),
SpotLag = new Frequency("2b")
};
fxMatrix.Init(usd, ValDate, new Dictionary <Currency, double> {
{ zar, 20.0 }
}, new List <FxPair> {
fxPair
}, new Dictionary <Currency, string> {
{ zar, "ZAR-IR" }, { usd, "USD-IR" }
});
var fModel = new FundingModel(ValDate, new[] { irCurveUsd, irCurveZar }, TestProviderHelper.CurrencyProvider, TestProviderHelper.CalendarProvider);
fModel.SetupFx(fxMatrix);
var fxSurface = new ConstantVolSurface(ValDate, 0.16);
fModel.VolSurfaces.Add("USD/ZAR", fxSurface);
var crudeCurve = new ConstantPriceCurve(100, ValDate, TestProviderHelper.CurrencyProvider)
{
Name = "OIL",
AssetId = "OIL",
Currency = usd
};
var crudeSurface = new ConstantVolSurface(ValDate, 0.32)
{
Name = "OIL",
AssetId = "OIL",
Currency = usd
};
var aModel = new AssetFxModel(ValDate, fModel);
aModel.AddPriceCurve("OIL", crudeCurve);
aModel.AddVolSurface("OIL", crudeSurface);
aModel.CorrelationMatrix = new CorrelationMatrix(new[] { "OIL" }, new[] { "USD/ZAR" }, new double[][] { new [] { 0.5 } });
return(aModel);
}
public void FxForwardCurveFact()
{
var originDate = new DateTime(2019, 05, 28);
var zar = TestProviderHelper.CurrencyProvider.GetCurrency("ZAR");
var usd = TestProviderHelper.CurrencyProvider.GetCurrency("USD");
var zarCurve = new ConstantRateIrCurve(0.07, originDate, "ZARCurve", zar);
var usdCurve = new ConstantRateIrCurve(0.02, originDate, "USDCurve", usd);
var fModel = new FundingModel(originDate, new[] { zarCurve, usdCurve }, TestProviderHelper.CurrencyProvider, TestProviderHelper.CalendarProvider);
var fxMatrix = new FxMatrix(TestProviderHelper.CurrencyProvider);
var fxPair = new FxPair {
Domestic = zar, Foreign = usd, SpotLag = new Dates.Frequency("0d")
};
fxMatrix.Init(zar, originDate, new Dictionary <Currency, double> {
{ usd, 10.0 }
}, new List <FxPair>()
{
fxPair
}, new Dictionary <Currency, string> {
{ usd, "USDCurve" }, { zar, "ZARCurve" }
});
fModel.SetupFx(fxMatrix);
var sut = new FxForwardCurve(originDate, fModel, zar, usd)
{
Name = "gooo",
};
var sut2 = new FxForwardCurve(originDate, new Func <Models.IFundingModel>(() => fModel), zar, usd);
Assert.Equal(10, sut.GetPriceForDate(originDate));
Assert.Equal(10, sut2.GetPriceForDate(originDate));
Assert.Equal(10, sut.GetPriceForFixingDate(originDate));
Assert.Equal(10, sut.GetAveragePriceForDates(new[] { originDate }));
Assert.Equal("gooo", sut.Name);
Assert.Equal(new Dictionary <string, IPriceCurve>(), sut.GetDeltaScenarios(0.0, null));
Assert.Equal(PriceCurveType.Linear, sut.CurveType);
Assert.True(sut.UnderlyingsAreForwards);
Assert.Equal(0, sut.NumberOfPillars);
Assert.Equal(usd.Ccy, sut.AssetId);
Assert.Null(sut.PillarDates);
Assert.Throws <NotImplementedException>(() => sut.RebaseDate(DateTime.Today));
Assert.Throws <NotImplementedException>(() => sut.PillarDatesForLabel(""));
Assert.Throws <Exception>(() => sut.Currency = null);
}
public void CDSStripperFacts()
{
var origin = new DateTime(2020, 06, 15);
var usd = TestProviderHelper.CurrencyProvider.GetCurrency("USD");
var df = new ConstantRateIrCurve(0.05, origin, "LIBOR", usd);
var data = new Tuple <Frequency, double>[]
{
new Tuple <Frequency, double>(1.Years(), 0.01),
new Tuple <Frequency, double>(2.Years(), 0.012),
new Tuple <Frequency, double>(3.Years(), 0.013),
new Tuple <Frequency, double>(4.Years(), 0.0135),
new Tuple <Frequency, double>(5.Years(), 0.014),
};
var cdses = data.Select(d => new CDS()
{
Basis = DayCountBasis.ACT365F,
Currency = usd,
OriginDate = origin,
Tenor = d.Item1,
Spread = d.Item2,
Notional = 1e6
}).ToList();
foreach (var cds in cdses)
{
cds.Init();
}
var sut = new NewtonRaphsonCreditCurveSolver
{
UseSmallSteps = true
};
var hz = sut.Solve(cdses, 0.4, df, origin);
var pz = cdses.Select(c => hz.GetSurvivalProbability(c.FinalSensitivityDate));
foreach (var p in pz)
{
Assert.True(!double.IsNaN(p));
}
}
public void IrCurveFact()
{
var z = new ConstantRateIrCurve(0.1, DateTime.Today, "xxx", TestProviderHelper.CurrencyProvider.GetCurrency("USD"));
Assert.Equal(0.1, z.GetForwardCCRate(DateTime.Today, DateTime.Today.AddDays(10)), 12);
Assert.Equal(0.1, z.GetRates()[0]);
Assert.Equal(0.2, z.SetRate(0, 0.2, false).GetRate(0));
Assert.Equal(0.25, z.BumpRateFlat(0.15, false).GetRate(0));
Assert.Equal(0.25, z.BumpRateFlat(0.15, true).GetRate(0));
z.SetCollateralSpec("cooo");
Assert.Equal("cooo", z.CollateralSpec);
z.SetRateIndex(new FloatRateIndex {
ResetTenor = new Dates.Frequency("7b")
});
Assert.Equal(7, z.RateIndex.ResetTenor.PeriodCount);
Assert.Equal(Interpolator1DType.DummyPoint, z.InterpolatorType);
}
public void CDSBasicFacts_LinearApprox()
{
var origin = new DateTime(2020, 06, 15);
var hzi = new ConstantHazzardInterpolator(0.0);
var hz = new HazzardCurve(origin, DayCountBasis.ACT365F, hzi);
var usd = TestProviderHelper.CurrencyProvider.GetCurrency("USD");
var df = new ConstantRateIrCurve(0.00, origin, "LIBOR", usd);
var sut = new CDS()
{
Basis = DayCountBasis.ACT365F,
Currency = usd,
OriginDate = origin,
Tenor = new Frequency("1y"),
Spread = 0.01,
Notional = 1e6
};
sut.Init();
var pv = sut.PV_LinearApprox(hz, df, 0.4, false);
Assert.Equal(-sut.Notional * sut.Spread, pv);
}
//https://www.moodysanalytics.com/-/media/whitepaper/2014/2014-20-05-standardized-approach-for-capitalizing-counterparty-credit-risk-exposures.pdf
//Example netting set #3
public void MoodysTest1()
{
var usd = TestProviderHelper.CurrencyProvider.GetCurrency("USD");
var origin = DateTime.Parse("2019-02-05");
var zeroCurve = new ConstantRateIrCurve(0.0, origin, "zero", usd);
var fm = new FundingModel(origin, new[] { zeroCurve }, TestProviderHelper.CurrencyProvider, TestProviderHelper.CalendarProvider);
var model = new AssetFxModel(origin, fm);
model.AddPriceCurve("Crude", new ConstantPriceCurve(100, origin, TestProviderHelper.CurrencyProvider));
model.AddPriceCurve("Silver", new ConstantPriceCurve(10, origin, TestProviderHelper.CurrencyProvider));
var assetToSetMap = new Dictionary <string, string>
{
{ "Crude", "Energy" },
{ "Silver", "Metals" },
};
var tradeA = new Forward()
{
AssetId = "Crude",
ExpiryDate = origin.AddDays(9 * 365 / 12.0),
PaymentDate = origin.AddDays(9 * 365 / 12.0),
Notional = 100000,
Strike = 100.5,
PaymentCurrency = usd,
DiscountCurve = "zero",
TradeId = "tradeA"
};
var tradeB = new Forward()
{
AssetId = "Crude",
ExpiryDate = origin.AddDays(2 * 365),
PaymentDate = origin.AddDays(2 * 365),
Notional = -200000,
Strike = 99.85,
PaymentCurrency = usd,
DiscountCurve = "zero",
TradeId = "tradeB"
};
var tradeC = new Forward()
{
AssetId = "Silver",
ExpiryDate = origin.AddDays(5 * 365),
PaymentDate = origin.AddDays(5 * 365),
Notional = 1000000,
Strike = 9.9,
PaymentCurrency = usd,
DiscountCurve = "zero",
TradeId = "tradeC"
};
var pvA = tradeA.PV(model, false);
var pvB = tradeB.PV(model, false);
var pvC = tradeC.PV(model, false);
var pf = new Portfolio()
{
Instruments = new List <IInstrument> {
tradeA, tradeB, tradeC
}
};
var pvPf = pf.PV(model);
Assert.Equal(20000.0, pvPf.GetAllRows().Sum(x => x.Value), 8);
var epe = System.Math.Max(0, pvPf.SumOfAllRows);
var ead = pf.SaCcrEAD(epe, model, usd, assetToSetMap);
Assert.Equal(5408608, ead, 0);
}
