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));
            }
        }
示例#6
0
        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);
            }
        }
示例#7
0
        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);
        }
示例#14
0
        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);
        }
示例#15
0
        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));
        }
示例#16
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);
                }
            }
        }
 bool IsConnectedToPrevLayer(int v, SweepMode sweepMode) {
     return sweepMode == SweepMode.ComingFromAbove && ProperLayeredGraph.InEdgesCount(v) > 0 ||
            sweepMode == SweepMode.ComingFromBelow && ProperLayeredGraph.OutEdgesCount(v) > 0;
 }
示例#18
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);

                }
            }

        }
示例#19
0
        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);
 }