public Dictionary <string, List <string> > FindDependencies(IFxMatrix matrix)
{
var dependencies = new Dictionary <string, List <string> >();
foreach (var curveName in SolveCurves)
{
var insForCurve = this.Where(x => x.SolveCurve == curveName);
dependencies.Add(curveName, new List <string>());
var deps = insForCurve.SelectMany(x => x.Dependencies(matrix)).Distinct();
if (deps.Any())
{
dependencies[curveName].AddRange(deps);
}
}
var sumAllDeps = -1;
var breakout = 0;
while (dependencies.Sum(x => x.Value.Count) > sumAllDeps && breakout < 20)
{
sumAllDeps = dependencies.Sum(x => x.Value.Count);
foreach (var curveName in SolveCurves)
{
var depsForCurve = dependencies[curveName];
var newTotalDeps = depsForCurve.SelectMany(d => dependencies[d]).Distinct().ToList();
dependencies[curveName] = newTotalDeps;
}
breakout++;
}
return(dependencies);
}
public static object CreateFundingModelParallel(
[ExcelArgument(Description = "Funding model name")] string ObjectName,
[ExcelArgument(Description = "Build date")] DateTime BuildDate,
[ExcelArgument(Description = "Funding instrument collection")] string FundingInstrumentCollection,
[ExcelArgument(Description = "Curve to solve stage mappings")] object SolveStages,
[ExcelArgument(Description = "Fx matrix object")] object FxMatrix,
[ExcelArgument(Description = "Fx vol surfaces")] object FxVolSurfaces)
{
return(ExcelHelper.Execute(_logger, () =>
{
ContainerStores.GetObjectCache <FundingInstrumentCollection>().TryGetObject(FundingInstrumentCollection, out var fic);
IFxMatrix fxMatrix = null;
if (!(FxMatrix is ExcelMissing))
{
var fxMatrixCache = ContainerStores.GetObjectCache <FxMatrix>();
fxMatrix = fxMatrixCache.GetObject((string)FxMatrix).Value;
}
var stageDict = fic.Value.ImplySolveStages2(fxMatrix);
var emptyCurves = fic.Value.ImplyContainedCurves(BuildDate, Interpolator1DType.LinearFlatExtrap);
var model = new FundingModel(BuildDate, emptyCurves.Values.ToArray(), ContainerStores.CurrencyProvider, ContainerStores.CalendarProvider);
if (!(FxMatrix is ExcelMissing))
{
model.SetupFx(fxMatrix);
}
if (!(FxVolSurfaces is ExcelMissing))
{
IEnumerable <IVolSurface> surfaces = null;
if (FxVolSurfaces is string vsStr)
{
surfaces = (new object[] { vsStr }).GetAnyFromCache <IVolSurface>();
}
else
{
surfaces = ((object[, ])FxVolSurfaces).GetAnyFromCache <IVolSurface>();
}
if (surfaces.Any())
{
model.VolSurfaces = surfaces.ToDictionary(k => k.Name, v => v);
}
}
if (fic != null)
{
var calibrator = new NewtonRaphsonMultiCurveSolverStaged()
{
InLineCurveGuessing = true
};
calibrator.Solve(model, fic.Value, stageDict);
}
return ExcelHelper.PushToCache <IFundingModel>(model, ObjectName);
}));
}
public Dictionary <string, List <string> > FindDependenciesInverse(IFxMatrix matrix)
{
var deps = FindDependencies(matrix);
var invDeps = new Dictionary <string, List <string> >();
foreach (var d in deps.Keys.ToArray())
{
invDeps[d] = deps.Where(x => x.Value.Contains(d)).Select(x => x.Key).ToList();
}
return(invDeps);
}
public List <string> Dependencies(IFxMatrix matrix) => (new[] { DiscountCurve, ForecastCurve }).Distinct().Where(x => x != SolveCurve).ToList();
public List <string> Dependencies(IFxMatrix matrix) => new List <string>();
public void SetupFx(IFxMatrix fxMatrix) => FxMatrix = fxMatrix;
public List <string> Dependencies(IFxMatrix matrix)
{
var curves = new[] { ForecastCurvePay, ForecastCurveRec, DiscountCurve };
return(curves.Distinct().Where(x => x != SolveCurve).ToList());
}
public List <string> Dependencies(IFxMatrix matrix)
{
var curves = new[] { ForeignDiscountCurve, matrix.DiscountCurveMap[DomesticCCY], matrix.DiscountCurveMap[ForeignCCY] };
return(curves.Distinct().Where(x => x != SolveCurve).ToList());
}
public Dictionary <string, int> ImplySolveStages(IFxMatrix matrix)
{
var o = new Dictionary <string, int>();
var dependencies = new Dictionary <string, List <string> >();
foreach (var curveName in SolveCurves)
{
var insForCurve = this.Where(x => x.SolveCurve == curveName);
dependencies.Add(curveName, new List <string>());
var deps = insForCurve.SelectMany(x => x.Dependencies(matrix)).Where(x => x != curveName).Distinct();
if (deps.Any())
{
dependencies[curveName].AddRange(deps);
}
}
var currentStage = 0;
//first find any curves depending on no other
var noDepCurves = dependencies.Where(x => !x.Value.Any()).ToArray();
foreach (var curve in noDepCurves)
{
o.Add(curve.Key, currentStage);
currentStage++;
dependencies.Remove(curve.Key);
}
var currentCount = dependencies.Count();
while (dependencies.Any())
{
//first do curves which only have resolved dependencies
var resolvedCurves = o.Keys.ToList();
var canResolveThisTime = dependencies.Where(x => x.Value.All(y => resolvedCurves.Contains(y)));
foreach (var curve in canResolveThisTime.ToList())
{
o.Add(curve.Key, currentStage);
currentStage++;
dependencies.Remove(curve.Key);
}
//next detect curves which can be co-solved
var singleDependencyCurves = dependencies.Where(x => x.Value.Count() == 1).ToDictionary(x => x.Key, x => x.Value);
var coCurves = singleDependencyCurves.Where(x => singleDependencyCurves.ContainsKey(x.Value.First())).ToDictionary(x => x.Key, x => x.Value);
var coCurveKeys = coCurves.Keys;
foreach (var curve in coCurveKeys)
{
if (o.ContainsKey(curve))
{
continue;
}
o.Add(curve, currentStage);
dependencies.Remove(curve);
var sisterCurve = coCurves[curve].First();
o.Add(sisterCurve, currentStage);
dependencies.Remove(sisterCurve);
currentStage++;
}
if (currentCount == dependencies.Count())
{
throw new Exception($"Failed to make forward progress at stage {currentStage}");
}
currentCount = dependencies.Count();
}
return(o);
}
public List <string> Dependencies(IFxMatrix matrix)
{
var curves = new[] { CashDiscountCurve, matrix.DiscountCurveMap[MetalCCY], matrix.DiscountCurveMap[CashCCY] };
return(curves.Distinct().Where(x => x != SolveCurve).ToList());
}
