Esempio n. 1
0
        public Stat(string text, Func <float, float> formula, StatFormatter formatter, bool stacks = true, params StatModifier[] modifiers)
        {
            Text      = text;
            Stacks    = stacks;
            Formula   = formula;
            Formatter = formatter;
            Modifiers = modifiers;

            if (!Stacks && string.IsNullOrWhiteSpace(Formatter?.Color))
            {
                Formatter.Color = "#A0A0A0";
            }
        }
Esempio n. 2
0
        private void updateStatistic(Label label, Stat statistic)
        {
            DoOnGuiThread(label, () =>
            {
                if (statistic.SampleSize < 3)
                {
                    return;
                }

                double mean = statistic.Mean();
                double[] confidenceInterval = statistic.ConfidenceInterval90;
                label.Text = StatFormatter.FormatStatistic(mean, confidenceInterval);
            });
        }
        private void buttStart_Click(object sender, EventArgs e)
        {
            processStopped            = false;
            bestConfiguration         = null;
            testedConfigurationsCount = 0;
            validConfigurationsCount  = 0;
            minArrivedAfterStartRatio = 1;
            minAverageWaitingTime     = double.MaxValue;
            validConfigFound          = false;
            minCost = int.MaxValue;
            minLineBudgets.CopyTo(currentLineBudgets, 0);
            configsWithCurrentBudgetCount = 0;

            Thread thread = new Thread(() =>
            {
                simulation.SetMaxSimSpeed();
                for (int configurationIdx = 0; configurationIdx < configurationsToTestCount; configurationIdx++)
                {
                    // generate configuration
                    SimulationConfiguration config = GenerateConfiguration();

                    // test configuration
                    SetConfiguration(simulation, config);

                    simulation.Simulate((int)numReplicationsCount.Value, endTime - startTime);

                    if (processStopped)
                    {
                        return;
                    }

                    testedConfigurationsCount++;
                    DoOnGuiThread(labelTestedConfigCount, () =>
                    {
                        labelTestedConfigCount.Text = testedConfigurationsCount.ToString();
                    });

                    // check if better than best
                    bool isSimulationResultValid = IsSimulationResultValid(simulation);
                    bool hasBetterStats          =
                        hasBetterStatsThan(simulation, minAverageWaitingTime, minArrivedAfterStartRatio);
                    int currentCost = config.Cost();

                    bool isBetter = false;
                    if (bestConfiguration == null)
                    {
                        isBetter = true;
                    }
                    else if (!validConfigFound)
                    {
                        if (isSimulationResultValid || hasBetterStats)
                        {
                            isBetter = true;
                        }
                    }
                    else if (isSimulationResultValid)
                    {
                        if (currentCost < minCost ||
                            (currentCost == minCost && hasBetterStats))
                        {
                            isBetter = true;
                        }
                    }

                    if (isSimulationResultValid)
                    {
                        validConfigFound = true;
                        validConfigurationsCount++;
                        DoOnGuiThread(labelValidConfigCount, () =>
                        {
                            labelValidConfigCount.Text = validConfigurationsCount.ToString();
                        });
                    }

                    if (isBetter)
                    {
                        bestConfiguration = config;
                        PrintConfiguration(labelBestConfiguration, bestConfiguration);
                        minArrivedAfterStartRatio = simulation.ArrivedAfterStartRatioSim.Mean();
                        minAverageWaitingTime     = simulation.AveragePassengerWaitingTimeSim.Mean();
                        minCost = currentCost;
                        DoOnGuiThread(labelMinCost, () =>
                        {
                            labelMinCost.Text = minCost.ToString();
                            labelMinAverageWaitingTime.Text = StatFormatter.FormatStatistic(
                                simulation.AveragePassengerWaitingTimeSim.Mean(),
                                simulation.AveragePassengerWaitingTimeSim.ConfidenceInterval90);
                            labelMinArrivedAfterStartRatio.Text = StatFormatter.FormatStatistic(
                                simulation.ArrivedAfterStartRatioSim.Mean(),
                                simulation.ArrivedAfterStartRatioSim.ConfidenceInterval90);
                        });
                    }
                }
            });

            thread.Start();
        }