double FixedNodePosition(int v, SweepMode sweepMode) { Debug.Assert(sweepMode != SweepMode.Starting); LayerInfo layerInfo = layerInfos[LayerArrays.Y[v]]; return(sweepMode == SweepMode.ComingFromAbove ? XPosition(layerInfo.constrainedFromAbove[v]) : XPosition(layerInfo.constrainedFromBelow[v])); }
static bool NodeIsConstrained(int v, SweepMode sweepMode, LayerInfo layerInfo) { if (sweepMode == SweepMode.Starting) { return(false); } return(sweepMode == SweepMode.ComingFromAbove && NodeIsConstrainedAbove(v, layerInfo) || sweepMode == SweepMode.ComingFromBelow && NodeIsConstrainedBelow(v, layerInfo)); }
public void NotifySweepModeChange(SweepMode mode) { if (mode == SweepMode.Normal) { view = null; } else { CalSweepSectionView(); } }
/// <summary> /// /// </summary> /// <param name="blockRoot"></param> /// <param name="layerInfo"></param> /// <param name="sweepMode"></param> /// <returns>-1 if no node is constrained</returns> static int GetFixedBlockNode(int blockRoot, LayerInfo layerInfo, SweepMode sweepMode) { if (sweepMode == SweepMode.Starting) { return(-1); } if (sweepMode == SweepMode.ComingFromBelow) { return(GetFixedBlockNodeFromBelow(blockRoot, layerInfo)); } return(GetFixedBlockNodeFromAbove(blockRoot, layerInfo)); }
//at the moment we only are looking for the order of nodes in the layer void FillSolverWithoutKnowingLayerOrder(IEnumerable <int> layer, LayerInfo layerInfo, ISolverShell solver, SweepMode sweepMode) { foreach (int v in layer) { if (layerInfo.neigBlocks.ContainsKey(v)) { //v is a block root int blockNode = GetFixedBlockNode(v, layerInfo, sweepMode); if (blockNode != -1) { solver.AddVariableWithIdealPosition(v, FixedNodePosition(blockNode, sweepMode), ConstrainedVarWeight); } else { IEnumerable <int> t = from u in layerInfo.neigBlocks[v].Concat(new[] { v }) where IsConnectedToPrevLayer(u, sweepMode) select u; if (t.Any()) { blockNode = t.First(); solver.AddVariableWithIdealPosition(v, GetBaricenterOnPrevLayer(blockNode, sweepMode)); } } } else if (!BelongsToNeighbBlock(v, layerInfo)) { if (NodeIsConstrained(v, sweepMode, layerInfo)) { solver.AddVariableWithIdealPosition(v, FixedNodePosition(v, sweepMode), ConstrainedVarWeight); } else if (IsConnectedToPrevLayer(v, sweepMode)) { solver.AddVariableWithIdealPosition(v, GetBaricenterOnPrevLayer(v, sweepMode)); } } } AddGoalToKeepFlatEdgesShortOnBlockLevel(layerInfo, solver); foreach (var p in layerInfo.leftRight) { solver.AddLeftRightSeparationConstraint(p.Item1, p.Item2, GetGapBetweenBlockRoots(p.Item1, p.Item2)); } }
public static void Analyze( List <Country> countries, List <Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, ConcurrentBag <ModelResult> modelResults, string perCountrySummaryFilename, string crossCountrySummaryFilename, Object printLock) { // Simple sorting of successful runs PerCountryAnalysis(modelResults, perCountrySummaryFilename, printLock); if (sweepMode == SweepMode.SweepAndCountry) { CrossCountryAnalysis(countries, models, portfolio, sweepMode, sweeps, modelResults, perCountrySummaryFilename, crossCountrySummaryFilename, printLock); } }
public static void Analyze( List<Country> countries, List<Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, ConcurrentBag<ModelResult> modelResults, string perCountrySummaryFilename, string crossCountrySummaryFilename, Object printLock) { // Simple sorting of successful runs PerCountryAnalysis(modelResults, perCountrySummaryFilename, printLock); if (sweepMode == SweepMode.SweepAndCountry) { CrossCountryAnalysis(countries, models, portfolio, sweepMode, sweeps, modelResults, perCountrySummaryFilename, crossCountrySummaryFilename, printLock); } }
//at the moment we only are looking for the order of nodes in the layer void FillSolverWithoutKnowingLayerOrder(IEnumerable<int> layer, LayerInfo layerInfo, ISolverShell solver, SweepMode sweepMode) { foreach (int v in layer) if (layerInfo.neigBlocks.ContainsKey(v)) { //v is a block root int blockNode = GetFixedBlockNode(v, layerInfo, sweepMode); if (blockNode != -1) solver.AddVariableWithIdealPosition(v, FixedNodePosition(blockNode, sweepMode), ConstrainedVarWeight); else { IEnumerable<int> t = from u in layerInfo.neigBlocks[v].Concat(new[] { v }) where IsConnectedToPrevLayer(u, sweepMode) select u; if (t.Any()) { blockNode = t.First(); solver.AddVariableWithIdealPosition(v, GetBaricenterOnPrevLayer(blockNode, sweepMode)); } } } else if (!BelongsToNeighbBlock(v, layerInfo)) { if (NodeIsConstrained(v, sweepMode, layerInfo)) solver.AddVariableWithIdealPosition(v, FixedNodePosition(v, sweepMode), ConstrainedVarWeight); else if (IsConnectedToPrevLayer(v, sweepMode)) solver.AddVariableWithIdealPosition(v, GetBaricenterOnPrevLayer(v, sweepMode)); } AddGoalToKeepFlatEdgesShortOnBlockLevel(layerInfo, solver); foreach (var p in layerInfo.leftRight) solver.AddLeftRightSeparationConstraint(p.Item1, p.Item2, GetGapBetweenBlockRoots(p.Item1, p.Item2)); }
double FixedNodePosition(int v, SweepMode sweepMode) { Debug.Assert(sweepMode != SweepMode.Starting); LayerInfo layerInfo = layerInfos[LayerArrays.Y[v]]; return sweepMode == SweepMode.ComingFromAbove ? XPosition(layerInfo.constrainedFromAbove[v]) : XPosition(layerInfo.constrainedFromBelow[v]); }
double GetBaricenterOnPrevLayer(int v, SweepMode sweepMode) { Debug.Assert(sweepMode != SweepMode.Starting); return(sweepMode == SweepMode.ComingFromAbove ? GetBaricenterAbove(v) : GetBaricenterBelow(v)); }
double GetBaricenterOnPrevLayer(int v, SweepMode sweepMode) { Debug.Assert(sweepMode != SweepMode.Starting); return sweepMode == SweepMode.ComingFromAbove ? GetBaricenterAbove(v) : GetBaricenterBelow(v); }
bool IsConnectedToPrevLayer(int v, SweepMode sweepMode) { return(sweepMode == SweepMode.ComingFromAbove && ProperLayeredGraph.InEdgesCount(v) > 0 || sweepMode == SweepMode.ComingFromBelow && ProperLayeredGraph.OutEdgesCount(v) > 0); }
/// <summary> /// /// </summary> /// <param name="blockRoot"></param> /// <param name="layerInfo"></param> /// <param name="sweepMode"></param> /// <returns>-1 if no node is constrained</returns> static int GetFixedBlockNode(int blockRoot, LayerInfo layerInfo, SweepMode sweepMode) { if (sweepMode == SweepMode.Starting) return -1; if (sweepMode == SweepMode.ComingFromBelow) return GetFixedBlockNodeFromBelow(blockRoot, layerInfo); return GetFixedBlockNodeFromAbove(blockRoot, layerInfo); }
static void Execute( List <Country> countries, List <Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, string resFile, string perCountrySummaryFilename, string crossCountrySummaryFilename) { ConcurrentBag <ModelResult> modelResults = new ConcurrentBag <ModelResult>(); Object printLock = new Object(); using (StreamWriter swr = new StreamWriter(resFile)) { swr.WriteLine(Utils.ResultHeader); if (sweepMode == SweepMode.No) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSingle(countries, models, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteDouble(countries, models, modelResults, swr, printLock); } } else if (sweepMode == SweepMode.SweepNoCountry) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSweepSingle(countries, models, sweeps, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteSweepDouble(countries, models, sweeps, modelResults, swr, printLock); } } else if (sweepMode == SweepMode.SweepAndCountry) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSweepSingleByCountry(countries, models, sweeps, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteSweepDoubleByCountry(countries, models, sweeps, modelResults, swr, printLock); } } } Analysis.Analyze( countries, models, portfolio, sweepMode, sweeps, modelResults, perCountrySummaryFilename, crossCountrySummaryFilename, printLock); }
static void Main(string[] args) { string globalFileName, modelsFilename, countriesFileName; Portfolio portfolio = Portfolio.Single; SweepMode sweepMode = SweepMode.No; SweepParameters[] sweeps = new SweepParameters[1]; int nFactors = 0; const int maxFactors = 10; Factor[] factors = new Factor[maxFactors]; int cp = 0; for (int f = 0; f < factors.Length; f++) { factors[f] = Factor.None; } // Global params file if (args.Length <= cp) { Console.Write("Usage: <globals.csv> <countries.csv> <models.csv> [single|dual] [sweep N factor-1 ... factor-n]"); return; } globalFileName = args[cp++]; Globals.ReadParams(globalFileName); string resultPrefix = "R_" + Globals.Singleton().Prefix; // Countries file if (args.Length <= cp) { Console.Write("Second parameter must point to the countries file"); return; } countriesFileName = args[cp++]; List <Country> countries = Country.ReadCountries(countriesFileName, false); // Models file if (args.Length <= cp) { Console.Write("Third parameter must point to the models file"); return; } modelsFilename = args[cp++]; List <Model> models = Model.ReadModels(modelsFilename); // Portfolio Composition Mode if (args.Length > cp) { if (args[cp].ToLower().Trim() == "single") { Console.WriteLine("The whole portfolio is managed as one thing"); portfolio = Portfolio.Single; resultPrefix += "_Single"; } else if (args[cp].ToLower().Trim() == "double") { portfolio = Portfolio.Double; Console.WriteLine("The portfolio is composed of 2 separate parts: all countries except last, and last"); resultPrefix += "_Double"; } else { Console.WriteLine("First parameter can be only 'single' or 'double'. It defines portfolio composition"); return; } cp++; } // Sweep mode if (args.Length > cp) { if (args[cp].ToLower().Trim() != "sweep") { Console.WriteLine("This parameter can be only 'sweep'. It would request sweep by few listed parameters."); return; } else { sweepMode = SweepMode.SweepNoCountry; resultPrefix += "_Sweep"; } cp++; } if (sweepMode != SweepMode.No) { // Sweep factors counter if (args.Length > cp) { nFactors = int.Parse(args[cp]); if (nFactors >= maxFactors) { Console.WriteLine("You cannot Sweep by more than {0} factors", maxFactors); return; } Console.WriteLine("Sweep is requested for {0} factors", nFactors); cp++; } else { Console.WriteLine("This parameter can be only sweep factor count"); return; } for (int i = 0; i < nFactors; i++) { //Country| Strategy | Withdrawal | DualShare | Eq | Bo switch (args[cp].ToLower().Trim()) { case "country": sweepMode = SweepMode.SweepAndCountry; resultPrefix += "_Country"; break; case "str": factors[i] = Factor.Strategy; resultPrefix += "_Strategy"; break; case "world": factors[i] = Factor.WorldShare; resultPrefix += "_World"; break; case "wd": factors[i] = Factor.Withdrawal; resultPrefix += "_Withdrawal"; break; case "eq": factors[i] = Factor.Equity; resultPrefix += "_Equity"; break; case "bo": factors[i] = Factor.Bonds; resultPrefix += "_Bonds"; break; default: Console.Write("This parameter can be only Country| Strategy | Withdrawal | WorldShare | Equity | Bonds"); return; } cp++; } } // Prepare sweep parameters if (sweepMode != SweepMode.No) { sweeps = Utils.Factorize(factors, countries); Console.WriteLine("You requested to sweep across {0} combinations", sweeps.Length); } // Create results dir and copy controling files Utils.CreateResultDir(resultPrefix, globalFileName, countriesFileName, modelsFilename); Utils.SaveCommand(Utils.CommandFileName(resultPrefix), args); // Run simulations Execute( countries, models, portfolio, sweepMode, sweeps, Utils.ResultFileName(resultPrefix), Utils.PerCountryFileName(resultPrefix), Utils.CrossCountryFileName(resultPrefix)); }
public static void CrossCountryAnalysis( List <Country> countries, List <Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, ConcurrentBag <ModelResult> modelResults, string perCountrySummaryFilename, string crossCountrySummaryFilename, Object printLock) { Dictionary <SweepParameters, SweepStat> sorter = new Dictionary <SweepParameters, SweepStat>(); foreach (ModelResult mr in modelResults) { SweepParameters swp = new SweepParameters(); swp.Country = -1; swp.WithdrawalRate = mr.model.YearlyWithdrawal; swp.WorldShare = mr.model.WorldShare; swp.Equity = mr.model.StartEq; swp.Bonds = mr.model.StartBo; swp.Strategy = mr.model.Strategy; int countryIndex = 0; foreach (Country c in countries) { if (c.Filename == mr.model.CountryName) { break; } else { countryIndex++; } } if (!sorter.ContainsKey(swp)) { SweepStat sws = new SweepStat(); sws.sweepResults = new Dictionary <int, List <ModelResult> >(); sorter.Add(swp, sws); } if (!sorter[swp].sweepResults.ContainsKey(countryIndex)) { sorter[swp].sweepResults.Add(countryIndex, new List <ModelResult>()); } sorter[swp].sweepResults[countryIndex].Add(mr); } List <SweepResult> sweepResults = new List <SweepResult>(); foreach (SweepParameters swp in sorter.Keys) { SweepStat sws = sorter[swp]; foreach (int country in sorter[swp].sweepResults.Keys) { foreach (ModelResult mr in sorter[swp].sweepResults[country]) { sws.totalPop += countries[country].Population; sws.weightedProd += mr.productivity * countries[country].Population; sws.weightedSuccessRate += mr.overallSuccessRate * countries[country].Population; } } sws.weightedProd /= sws.totalPop; sws.weightedSuccessRate /= sws.totalPop; SweepResult swr = new SweepResult(); swr.parameters = swp; swr.stat = sws; sweepResults.Add(swr); } IEnumerable <SweepResult> sortedResults = sweepResults.OrderBy( sr => (sr.stat.weightedSuccessRate * 10000.0 + sr.stat.weightedProd)); using (StreamWriter sw = new StreamWriter(crossCountrySummaryFilename)) { sw.WriteLine("WdRate,Strategy,World,Eq,Bo,Prod,Success,"); foreach (SweepResult sr in sortedResults) { sw.WriteLine("{0:F2},{1},{2:F2},{3},{4},{5:F2},{6:F2},", sr.parameters.WithdrawalRate, sr.parameters.Strategy, sr.parameters.WorldShare, sr.parameters.Equity, sr.parameters.Bonds, sr.stat.weightedProd, sr.stat.weightedSuccessRate); } } }
bool IsConnectedToPrevLayer(int v, SweepMode sweepMode) { return sweepMode == SweepMode.ComingFromAbove && ProperLayeredGraph.InEdgesCount(v) > 0 || sweepMode == SweepMode.ComingFromBelow && ProperLayeredGraph.OutEdgesCount(v) > 0; }
public static void CrossCountryAnalysis( List<Country> countries, List<Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, ConcurrentBag<ModelResult> modelResults, string perCountrySummaryFilename, string crossCountrySummaryFilename, Object printLock) { Dictionary<SweepParameters, SweepStat> sorter = new Dictionary<SweepParameters, SweepStat>(); foreach (ModelResult mr in modelResults) { SweepParameters swp = new SweepParameters(); swp.Country = -1; swp.WithdrawalRate = mr.model.YearlyWithdrawal; swp.WorldShare = mr.model.WorldShare; swp.Equity = mr.model.StartEq; swp.Bonds = mr.model.StartBo; swp.Strategy = mr.model.Strategy; int countryIndex = 0; foreach(Country c in countries) { if (c.Filename == mr.model.CountryName) break; else countryIndex++; } if (!sorter.ContainsKey(swp)) { SweepStat sws = new SweepStat(); sws.sweepResults = new Dictionary<int, List<ModelResult>>(); sorter.Add(swp, sws); } if (!sorter[swp].sweepResults.ContainsKey(countryIndex)) sorter[swp].sweepResults.Add(countryIndex, new List<ModelResult>()); sorter[swp].sweepResults[countryIndex].Add(mr); } List<SweepResult> sweepResults = new List<SweepResult>(); foreach(SweepParameters swp in sorter.Keys) { SweepStat sws = sorter[swp]; foreach (int country in sorter[swp].sweepResults.Keys) { foreach (ModelResult mr in sorter[swp].sweepResults[country]) { sws.totalPop += countries[country].Population; sws.weightedProd += mr.productivity * countries[country].Population; sws.weightedSuccessRate += mr.overallSuccessRate * countries[country].Population; } } sws.weightedProd /= sws.totalPop; sws.weightedSuccessRate /= sws.totalPop; SweepResult swr = new SweepResult(); swr.parameters = swp; swr.stat = sws; sweepResults.Add(swr); } IEnumerable<SweepResult> sortedResults = sweepResults.OrderBy( sr => (sr.stat.weightedSuccessRate * 10000.0 + sr.stat.weightedProd)); using (StreamWriter sw = new StreamWriter(crossCountrySummaryFilename)) { sw.WriteLine("WdRate,Strategy,World,Eq,Bo,Prod,Success,"); foreach (SweepResult sr in sortedResults) { sw.WriteLine("{0:F2},{1},{2:F2},{3},{4},{5:F2},{6:F2},", sr.parameters.WithdrawalRate, sr.parameters.Strategy, sr.parameters.WorldShare, sr.parameters.Equity, sr.parameters.Bonds, sr.stat.weightedProd, sr.stat.weightedSuccessRate); } } }
static void Execute( List<Country> countries, List<Model> models, Portfolio portfolio, SweepMode sweepMode, SweepParameters[] sweeps, string resFile, string perCountrySummaryFilename, string crossCountrySummaryFilename) { ConcurrentBag<ModelResult> modelResults = new ConcurrentBag<ModelResult>(); Object printLock = new Object(); using (StreamWriter swr = new StreamWriter(resFile)) { swr.WriteLine(Utils.ResultHeader); if (sweepMode == SweepMode.No) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSingle(countries, models, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteDouble(countries, models, modelResults, swr, printLock); } } else if (sweepMode == SweepMode.SweepNoCountry) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSweepSingle(countries, models, sweeps, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteSweepDouble(countries, models, sweeps, modelResults, swr, printLock); } } else if (sweepMode == SweepMode.SweepAndCountry) { if (portfolio == Portfolio.Single) { Experiments.ExecuteSweepSingleByCountry(countries, models, sweeps, modelResults, swr, printLock); } else if (portfolio == Portfolio.Double) { Experiments.ExecuteSweepDoubleByCountry(countries, models, sweeps, modelResults, swr, printLock); } } } Analysis.Analyze( countries, models, portfolio, sweepMode, sweeps, modelResults, perCountrySummaryFilename, crossCountrySummaryFilename, printLock); }
static bool NodeIsConstrained(int v, SweepMode sweepMode, LayerInfo layerInfo) { if (sweepMode == SweepMode.Starting) return false; return sweepMode == SweepMode.ComingFromAbove && NodeIsConstrainedAbove(v, layerInfo) || sweepMode == SweepMode.ComingFromBelow && NodeIsConstrainedBelow(v, layerInfo); }