public static Model SweepModel(Model mp, SweepParameters sw, Country c)
{
Model m = new Model(mp.Strategy, mp.StartEq, mp.StartBo, mp.YearlyWithdrawal, mp.RebalanceEvery, c.Filename);
if (sw.Strategy >= 0)
{
m.Strategy = sw.Strategy;
}
if (sw.Equity >= 0)
{
m.StartEq = sw.Equity;
}
if (sw.Bonds >= 0)
{
m.StartBo = sw.Bonds;
}
if (sw.WithdrawalRate >= 0)
{
m.YearlyWithdrawal = sw.WithdrawalRate;
}
if (sw.WorldShare >= 0)
{
m.WorldShare = sw.WorldShare;
}
return(m);
}
public static Model SweepModel(Model mp, SweepParameters sw, Country c)
{
Model m = new Model(mp.Strategy, mp.StartEq, mp.StartBo, mp.YearlyWithdrawal, mp.RebalanceEvery, c.Filename);
if (sw.Strategy >= 0)
m.Strategy = sw.Strategy;
if (sw.Equity >= 0)
m.StartEq = sw.Equity;
if (sw.Bonds >= 0)
m.StartBo = sw.Bonds;
if (sw.WithdrawalRate >= 0)
m.YearlyWithdrawal = sw.WithdrawalRate;
if (sw.WorldShare >= 0)
m.WorldShare = sw.WorldShare;
return m;
}
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);
}
}
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);
}
}
}
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);
}
}
}
// Sweep run for a double-part portfolio by country
public static void ExecuteSweepDoubleByCountry(
List<Country> countries,
List<Model> models,
SweepParameters[] sweeps,
ConcurrentBag<ModelResult> modelResults,
StreamWriter swr,
Object printlock)
{
// Group2 is just the World
List<Country> countries2 = new List<Country>();
foreach (Country c in countries)
{
if (Globals.IsWorld(c.Filename))
{
countries2.Add(c);
countries2.Last().Weight = 1;
}
}
List<int> equityChanges2 = new List<int>();
List<int> bondChanges2 = new List<int>();
List<int> billChanges2 = new List<int>();
GraphAcquierer.Acquire(countries2, equityChanges2, bondChanges2, billChanges2, printlock);
Distro distroEquities2 = new Distro(Globals.Singleton().Bins);
Distro distroBonds2 = new Distro(Globals.Singleton().Bins);
Distro distroBills2 = new Distro(Globals.Singleton().Bins);
Distro.Prepare(
equityChanges2, bondChanges2, billChanges2,
distroEquities2, distroBonds2, distroBills2,
printlock);
// Now enumerate countries; Group1 each time will carry just one
foreach (var c in countries)
{
if (Globals.IsWorld(c.Filename))
continue;
List<Country> countries1 = new List<Country>();
countries1.Add(c);
countries1.Last().Weight = 1;
// Group1 is just one country
List<int> equityChanges1 = new List<int>();
List<int> bondChanges1 = new List<int>();
List<int> billChanges1 = new List<int>();
GraphAcquierer.Acquire(countries1, equityChanges1, bondChanges1, billChanges1, printlock);
Distro distroEquities1 = new Distro(Globals.Singleton().Bins);
Distro distroBonds1 = new Distro(Globals.Singleton().Bins);
Distro distroBills1 = new Distro(Globals.Singleton().Bins);
Distro.Prepare(
equityChanges1, bondChanges1, billChanges1,
distroEquities1, distroBonds1, distroBills1,
printlock);
lock (printlock)
{
Console.WriteLine(Utils.ResultHeader);
}
var res2 = Parallel.ForEach(
models,
(m) =>
{
var res1 = Parallel.ForEach(
sweeps,
(sw) =>
{
Model mm = Model.SweepModel(m, sw, c);
if (mm.Validate())
{
if (mm.StartEq + mm.StartBo <= 100)
{
List<SingleRunResult> result = Market.RunDoublePortfolioExperiment(
mm,
sw.WorldShare,
distroEquities1, distroBonds1, distroBills1,
distroEquities2, distroBonds2, distroBills2);
ModelResult mr = new ModelResult(mm, result);
modelResults.Add(mr);
Utils.WriteResult(null, mm, mr, printlock);
Utils.WriteResult(swr, mm, mr, printlock);
}
}
});
});
c.Weight = 0;
}
}
// Sweep run for a single portfolio by country
public static void ExecuteSweepSingleByCountry(
List<Country> countries,
List<Model> models,
SweepParameters[] sweeps,
ConcurrentBag<ModelResult> modelResults,
StreamWriter swr,
Object printlock)
{
foreach (var c in countries)
c.Weight = 0;
foreach (var c in countries)
{
c.Weight = 1;
List<int> equityChanges = new List<int>();
List<int> bondChanges = new List<int>();
List<int> billChanges = new List<int>();
GraphAcquierer.Acquire(countries, equityChanges, bondChanges, billChanges, printlock);
Distro distroEquities = new Distro(Globals.Singleton().Bins);
Distro distroBonds = new Distro(Globals.Singleton().Bins);
Distro distroBills = new Distro(Globals.Singleton().Bins);
Distro.Prepare(
equityChanges, bondChanges, billChanges,
distroEquities, distroBonds, distroBills,
printlock);
Distro.Test(
distroEquities, distroBonds, distroBills,
printlock);
lock (printlock)
{
Console.WriteLine(Utils.ResultHeader);
}
var res2 = Parallel.ForEach(
models,
(m) =>
{
var res1 = Parallel.ForEach(
sweeps,
(sw) =>
{
Model mm = Model.SweepModel(m, sw, c);
if (mm.Validate())
{
if (mm.StartEq + mm.StartBo <= 100)
{
List<SingleRunResult> result = Market.RunSinglePortfolioExperiment(
mm,
distroEquities, distroBonds, distroBills);
ModelResult mr = new ModelResult(mm, result);
modelResults.Add(mr);
Utils.WriteResult(null, mm, mr, printlock);
Utils.WriteResult(swr, mm, mr, printlock);
}
}
});
});
c.Weight = 0;
}
}
// Sweep run for a double-part portfolio
public static void ExecuteSweepDouble(
List<Country> countries,
List<Model> models,
SweepParameters[] sweeps,
ConcurrentBag<ModelResult> modelResults,
StreamWriter swr,
Object printlock)
{
// Separate countries into 2 groups: 2=WORLD, 1=all others
double weight1 = 0.0, weight2 = 0.0;
List<Country> countries1 = new List<Country>();
List<Country> countries2 = new List<Country>();
foreach (Country c in countries)
{
if (Globals.IsWorld(c.Filename))
{
countries2.Add(c);
weight2 += c.Weight;
}
else
{
countries1.Add(c);
weight1 += c.Weight;
}
}
if (weight1 <= 0 || weight2 <= 0)
throw new Exception("Cannot find the world or others");
// Group2 is just the World
List<int> equityChanges2 = new List<int>();
List<int> bondChanges2 = new List<int>();
List<int> billChanges2 = new List<int>();
GraphAcquierer.Acquire(countries2, equityChanges2, bondChanges2, billChanges2, printlock);
Distro distroEquities2 = new Distro(Globals.Singleton().Bins);
Distro distroBonds2 = new Distro(Globals.Singleton().Bins);
Distro distroBills2 = new Distro(Globals.Singleton().Bins);
Distro.Prepare(
equityChanges2, bondChanges2, billChanges2,
distroEquities2, distroBonds2, distroBills2,
printlock);
// Group1 is all except World
List<int> equityChanges1 = new List<int>();
List<int> bondChanges1 = new List<int>();
List<int> billChanges1 = new List<int>();
GraphAcquierer.Acquire(countries1, equityChanges1, bondChanges1, billChanges1, printlock);
Distro distroEquities1 = new Distro(Globals.Singleton().Bins);
Distro distroBonds1 = new Distro(Globals.Singleton().Bins);
Distro distroBills1 = new Distro(Globals.Singleton().Bins);
Distro.Prepare(
equityChanges1, bondChanges1, billChanges1,
distroEquities1, distroBonds1, distroBills1,
printlock);
lock (printlock)
{
Console.WriteLine(Utils.ResultHeader);
}
var res2 = Parallel.ForEach(
models,
(m) =>
{
var res1 = Parallel.ForEach(
sweeps,
(sw) =>
{
Country nullCountry = new Country();
Model mm = Model.SweepModel(m, sw, nullCountry);
if (mm.Validate())
{
List<SingleRunResult> result = Market.RunDoublePortfolioExperiment(
mm,
weight2 / (weight1 + weight2),
distroEquities1, distroBonds1, distroBills1,
distroEquities2, distroBonds2, distroBills2);
ModelResult mr = new ModelResult(mm, result);
modelResults.Add(mr);
Utils.WriteResult(null, mm, mr, printlock);
Utils.WriteResult(swr, mm, mr, printlock);
}
});
});
}
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 SweepParameters[] Factorize(Factor[] factors, List <Country> countries)
{
SweepParameters[] sweeps = new SweepParameters[1];
sweeps[0].Strategy = -1;
sweeps[0].Equity = -1;
sweeps[0].Bonds = -1;
sweeps[0].WorldShare = (double)Globals.Singleton().DoubleWorldWeight /
(double)(Globals.Singleton().DoubleWorldWeight + Globals.Singleton().DoubleCountryWeight);
sweeps[0].WithdrawalRate = -1;
sweeps[0].Country = -1;
int nCountries = countries.Count;
for (int f = 0; f < factors.Length; f++)
{
switch (factors[f])
{
case Factor.Strategy:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepStrategies.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepStrategies.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Strategy = Globals.Singleton().SweepStrategies[n];
c++;
}
}
}
break;
case Factor.Withdrawal:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepWithdrawalRates.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepWithdrawalRates.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].WithdrawalRate = Globals.Singleton().SweepWithdrawalRates[n];
c++;
}
}
}
break;
case Factor.WorldShare:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepWorldShares.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepWorldShares.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].WorldShare = Globals.Singleton().SweepWorldShares[n];
c++;
}
}
}
break;
case Factor.Equity:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepEquities.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepEquities.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Equity = Globals.Singleton().SweepEquities[n];
c++;
}
}
}
break;
case Factor.Bonds:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepBonds.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepBonds.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Bonds = Globals.Singleton().SweepBonds[n];
c++;
}
}
}
break;
case Factor.None:
break;
}
}
List <SweepParameters> sweeps1 = new List <SweepParameters>();
int count = 0;
for (int i = 0; i < sweeps.Length; i++)
{
if (sweeps[i].Equity + sweeps[i].Bonds <= 100)
{
sweeps1.Add(sweeps[i]);
count++;
}
}
sweeps = new SweepParameters[count];
int cn = 0;
foreach (SweepParameters s in sweeps1)
{
sweeps[cn++] = s;
}
return(sweeps);
}
public static SweepParameters[] Factorize(Factor[] factors, List<Country> countries)
{
SweepParameters[] sweeps = new SweepParameters[1];
sweeps[0].Strategy = -1;
sweeps[0].Equity = -1;
sweeps[0].Bonds = -1;
sweeps[0].WorldShare = (double)Globals.Singleton().DoubleWorldWeight /
(double)(Globals.Singleton().DoubleWorldWeight + Globals.Singleton().DoubleCountryWeight);
sweeps[0].WithdrawalRate = -1;
sweeps[0].Country = -1;
int nCountries = countries.Count;
for (int f = 0; f < factors.Length; f++)
{
switch (factors[f])
{
case Factor.Strategy:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepStrategies.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepStrategies.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Strategy = Globals.Singleton().SweepStrategies[n];
c++;
}
}
}
break;
case Factor.Withdrawal:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepWithdrawalRates.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepWithdrawalRates.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].WithdrawalRate = Globals.Singleton().SweepWithdrawalRates[n];
c++;
}
}
}
break;
case Factor.WorldShare:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepWorldShares.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepWorldShares.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].WorldShare = Globals.Singleton().SweepWorldShares[n];
c++;
}
}
}
break;
case Factor.Equity:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepEquities.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepEquities.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Equity = Globals.Singleton().SweepEquities[n];
c++;
}
}
}
break;
case Factor.Bonds:
{
SweepParameters[] oldSweeps = sweeps;
sweeps = new SweepParameters[oldSweeps.Length * Globals.Singleton().SweepBonds.Length];
int c = 0;
for (int o = 0; o < oldSweeps.Length; o++)
{
for (int n = 0; n < Globals.Singleton().SweepBonds.Length; n++)
{
sweeps[c] = oldSweeps[o];
sweeps[c].Bonds = Globals.Singleton().SweepBonds[n];
c++;
}
}
}
break;
case Factor.None:
break;
}
}
List<SweepParameters> sweeps1 = new List<SweepParameters>();
int count = 0;
for (int i = 0; i < sweeps.Length; i++)
{
if (sweeps[i].Equity + sweeps[i].Bonds <= 100)
{
sweeps1.Add(sweeps[i]);
count++;
}
}
sweeps = new SweepParameters[count];
int cn = 0;
foreach (SweepParameters s in sweeps1)
sweeps[cn++] = s;
return sweeps;
}
