コード例 #1
0
        public double RunXFoldTest(int fold)
        {
            var    rates = new List <double>();
            double diff;
            var    tries = 0;

            do
            {
                tries++;
                var rate = RunXFold(fold);
                rates.Add(rate);
                diff = rates.Count != 0 ? rates.StdDev() / Math.Sqrt(rates.Count) : rate;
            } while (diff > MaxDiff || tries < MinTries);
            Debug.WriteLine("Rate:{0} +/-{1}", rates.Average(), rates.StdDev());
            Debug.WriteLine("Min:{0} - Max:{1}", rates.Min(), rates.Max());
            return(rates.Average());
        }
コード例 #2
0
        public void HitRateAnalysis()
        {
            //stat vars
            var progress = new List <List <double> >();

            //read dataset
            var dataset = Factory.Read(Dataset);

            for (var ratio = MaxRatio; ratio >= MinRatio; ratio -= GapRatio)
            {
                var rates    = new List <double>();
                var rulesAmt = new List <int>();

                double diff;
                var    tries = 0;
                do
                {
                    //split dataset
                    var parts = Factory.Split(ratio, dataset, true);
                    var train = parts[0];
                    var test  = parts[1];

                    //run system
                    var rules   = CreateModel(train);
                    var hitRate = FastTest(rules, test);

                    //stats briefing
                    rulesAmt.Add(rules.RuleAmt());

                    //stop criteria
                    tries++;
                    rates.Add(hitRate / (double)test.Count);
                    diff = rates.Count != 0 ? rates.StdDev() / Math.Sqrt(rates.Count) : hitRate;
                } while (diff > MaxDiff || tries < MinTries);

                //ratio stat briefing
                var info = new List <double>
                {
                    ratio,
                    rates.Average(),
                    rates.Min(),
                    rates.Max(),
                    tries,
                    rulesAmt.Average(),
                };
                progress.Add(info);

                Debug.WriteLine(info.Aggregate("", (current, i) => current + (i + ";")));
            }

            WriteFiles(progress);
        }
コード例 #3
0
        public void TestStdDev()
        {
            List <decimal> testlist = new List <decimal>();

            testlist.Add(1);
            testlist.Add(2);
            testlist.Add(3);
            testlist.Add(4);

            decimal result = testlist.StdDev();

            Assert.AreEqual((decimal)Math.Round(result, 5), 1.29099m);
        }
コード例 #4
0
        public double CalculateReward(int handovers, long leftoverDueTime)
        {
            double     reward        = 0;
            List <int> currentBuffer = new List <int>();

            foreach (var buffer in Buffers)
            {
                currentBuffer.Add(buffer.Blocks.Count);
                var highestReadyIndex = -1;
                var distToTop         = 0;
                var bufferList        = buffer.Blocks.ToArray();
                for (int i = 0; i < buffer.Blocks.Count; i++)
                {
                    var block = bufferList[i];
                    if (block.Ready)
                    {
                        highestReadyIndex = i;
                        distToTop         = 0;
                    }
                    else
                    {
                        distToTop++;
                    }
                }
                if (highestReadyIndex != -1)
                {
                    reward -= 10 * distToTop;
                }
            }

            var stdDev = currentBuffer.StdDev();
            var maxStdDev = new List <int> {
                0, Buffers.First().MaxHeight
            }.StdDev();
            var bufferReward = (1 - (stdDev / maxStdDev)) * 10;

            reward += bufferReward;

            reward += 10 * (Production.MaxHeight - Production.Blocks.Count);

            if (Handover.Blocks.Count > 0)
            {
                reward += 500 + Handover.Blocks.First().Due.MilliSeconds;
            }

            reward += 500 * handovers + leftoverDueTime;

            return(reward);
        }
コード例 #5
0
        public StandardDeviationTestResult StandardDeviationTest <T>(T rng) where T : IRngInterface
        {
            var values = new List <int>();

            for (var i = 0; i < _testsSettings.StandardDeviationTest.Samples; i++)
            {
                values.Add(rng.Next(_testsSettings.StandardDeviationTest.Max));
            }

            return(new StandardDeviationTestResult
            {
                StandardDeviation = values.StdDev(true),
                CoefficientOfVariation = values.CoeffVar(true),
                RngName = rng.Name
            });
        }
コード例 #6
0
 private static void MeasureDiameters()
 {
     for (int r = 3; r <= 9; r += 2)
     {
         Console.WriteLine($"N\tDiameter\tVariance\t[r={r}]");
         for (int n = 10; n <= 1e3; n += 99)
         {
             var list = new List <double>();
             for (int i = 0; i < 100; i++)
             {
                 var graph = new RandomRegularGraphBuilder().Build(n, r);
                 list.Add(graph.GetDiameter());
             }
             Console.WriteLine($"{n}\t{list.Average().ToString("0.00")}\t{list.StdDev().ToString("0.00")}");
         }
     }
 }
コード例 #7
0
    static void Main(string[] args)
    {
        List <double> testResults = new List <double>();
        Stopwatch     sw          = new Stopwatch();
        int           upperBound  = int.Parse(args[0]) + 1;
        int           tests       = int.Parse(args[1]);
        int           lowerBound  = int.Parse(args[2]); // THIS LINE CHANGES
        int           sum         = 0;

        for (int iTest = 0; iTest < tests; iTest++)
        {
            sum = 0;
            GC.Collect();
            sw.Reset();
            sw.Start();
            for (int lvl1 = lowerBound; lvl1 < upperBound; lvl1++)
            {
                for (int lvl2 = lowerBound; lvl2 < upperBound; lvl2++)
                {
                    for (int lvl3 = lowerBound; lvl3 < upperBound; lvl3++)
                    {
                        for (int lvl4 = lowerBound; lvl4 < upperBound; lvl4++)
                        {
                            for (int lvl5 = lowerBound; lvl5 < upperBound; lvl5++)
                            {
                                sum++;
                            }
                        }
                    }
                }
            }
            sw.Stop();
            testResults.Add(sw.Elapsed.TotalMilliseconds);
        }
        double avg = testResults.Average();
        double stdev = testResults.StdDev();
        string fmt = "{0,13} {1,13} {2,13} {3,13}"; string bar = new string('-', 13);

        Console.WriteLine();
        Console.WriteLine(fmt, "Iterations", "Average (ms)", "Std Dev (ms)", "Per It. (ns)");
        Console.WriteLine(fmt, bar, bar, bar, bar);
        Console.WriteLine(fmt, sum, avg.ToString("F3"), stdev.ToString("F3"),
                          ((avg * 1000000) / (double)sum).ToString("F3"));
    }
コード例 #8
0
        public RouletteSelection(IEnumerable <T> infos, Func <T, K> selkey, Func <K, float> selfit)
        {
            MinFit        = float.MaxValue;
            TotalSpaceSum = 0;

            foreach (var info in infos)
            {
                var space = new RouletteSpace <K>()
                {
                    Id = selkey(info),
                };
                space.Fit = selfit(space.Id);

                if (space.Fit < MinFit)
                {
                    MinFit = space.Fit;
                }
                Wheel.Add(space);
            }

            if (!Wheel.Any())
            {
                MinFit     = 0f;
                MaxFit     = 0f;
                AverageFit = 0f;
                return;
            }

            MaxFit     = Wheel.Max(sp => sp.Fit);
            AverageFit = Wheel.Average(sp => sp.Fit);
            StdDevFit  = Wheel.StdDev(sp => sp.Fit);

            var limit    = AverageFit - StdDevFit / 10f;
            var goodlist = Wheel.Where(sp => sp.Fit >= limit);

            WheelAverageOrBetter = goodlist.Count() > 100 ? goodlist.ToArray() : Wheel.ToArray();

            foreach (var one in Wheel)
            {
                one.Space      = one.Fit - MinFit + 1;
                TotalSpaceSum += one.Space;
            }
        }
コード例 #9
0
 private double?GetStdDev(List <int> list)
 {
     return(list.StdDev());
 }
コード例 #10
0
ファイル: EventProfiler.cs プロジェクト: miguelqvd/QSTK.Net
        public void Study(string filename, bool plotErrorBars, bool plotMarketNeutral, bool plotEvents, string marketSymbol)
        {
            Console.WriteLine("Starting Event Study");

            // compute 0 centered daily returns
            foreach (var symbol in symbols)
            {
                var symList = close.ColumnList(symbol);
                dailyReturns[symbol] = symList.Returnize();
            }

            var marketList = close.ColumnList(marketSymbol);
            IList<float> marketDaily = marketList.Returnize();

            // make it market neutral
            if (plotMarketNeutral)
            {
                foreach (var symbol in symbols)
                {
                    marketNeutralDm[symbol] = new List<float>();
                    for (int i = 0; i < marketDays; i++)
                        marketNeutralDm[symbol].Add(dailyReturns[symbol][i] - marketDaily[i]);
                }

                // remove the market column from consideration
                marketNeutralDm.Remove(marketSymbol);
                IList<int> removedEventList;
                eventMatrix.TryRemove(marketSymbol, out removedEventList);
                symbols.Remove(marketSymbol);
            }
            else
            {
                marketNeutralDm = dailyReturns;
            }

            // Wipe out events which are on the boundary.
            Parallel.ForEach(symbols,
                             symbol =>
                             {
                                 foreach (int i in Enumerable.Range(0, lookbackDays))
                                     eventMatrix[symbol][i] = 0;

                                 foreach (int i in Enumerable.Range(marketDays - lookforwardDays, lookforwardDays))
                                     eventMatrix[symbol][i] = 0;
                             });

            // prepare to build impact matrix
            var returns = marketNeutralDm;
            int numCols = eventMatrix.Keys.Count;

            int numEvents = eventMatrix.Values.SelectMany(i => i).Sum();

            // create a blank impact matrix
            var impact = new double[totalGraphDays, numEvents];

            int currcol = 0;
            // step through each event in event matrix
            foreach (int column in Enumerable.Range(0, numCols))
            {
                string currSym = symbols[column];
                // search event days
                int eventDays = eventMatrix[currSym].Count;
                foreach (int eventIndex in Enumerable.Range(0, eventDays))
                {
                    int eventState = eventMatrix[symbols[column]][eventIndex];

                    // when we find an event
                    if (eventState == 1)
                    {
                        // copy the daily returns in to the impact matrix
                        int start = eventIndex - lookbackDays;
                        start = (start < 0) ? 0 : start;
                        int end = eventIndex + lookforwardDays + 1;

                        for (int i = start, j = 0; i < end && j < eventDays; i++, j++)
                        {
                            impact[j, currcol] = returns[currSym][i];
                        }

                        currcol = currcol + 1;
                    }
                }
            }

            // now compute cumulative daily returns
            Parallel.ForEach(Enumerable.Range(0, impact.GetLength(1)),
                             j =>
                             {
                                 foreach (int i in Enumerable.Range(0, impact.GetLength(0)))
                                     impact[i, j] = impact[i, j] + 1.0d;
                             });

            impact = impact.CumulativeProduct();

            Parallel.ForEach(ParallelEnumerable.Range(0, impact.GetLength(1)),
                             j =>
                             {
                                 var divisor = impact[0, j];
                                 foreach (int i in Enumerable.Range(0, impact.GetLength(0)))
                                 {
                                     impact[i, j] = impact[i, j] / divisor;
                                 }
                             });

            // normalize everything to the time of the event
            Parallel.ForEach(ParallelEnumerable.Range(0, impact.GetLength(1)),
                             j =>
                             {
                                 var divisor = impact[lookbackDays, j];
                                 foreach (int i in Enumerable.Range(0, impact.GetLength(0)))
                                     impact[i, j] = impact[i, j] / divisor;
                             });

            // prepare data for plot
            studyStat = new List<float>(impact.GetLength(0));
            studyStd = new List<float>(impact.GetLength(0));
            foreach (int i in Enumerable.Range(0, impact.GetLength(0)))
            {
                var row = new List<float>();
                for (int j = 0; j < impact.GetLength(1); j++)
                {
                    row.Add((float)impact[i, j]);
                }
                studyStat.Add(row.Average());
                studyStd.Add(row.StdDev());
            }

            studyRange = Enumerable.Range(-lookbackDays, (lookbackDays + lookforwardDays + 1));

            Plot(filename, impact, numEvents, plotMarketNeutral, plotEvents, plotErrorBars);
        }
コード例 #11
0
ファイル: Program.cs プロジェクト: lanicon/tcpingsharp
        private static void PrintStats(ReadOnlyDictionary<IPAddress, ReadOnlyCollection<double>> stats, bool realRtt)
        {
            foreach (var (ipAddress, rawStats) in stats)
            {
                var extractedData = new List<double>(rawStats);

                Console.WriteLine($"--- {ipAddress} tcping statistics ---");

                // trim 0 (failed) from results
                var failed = extractedData.Count(x => x == 0);
                extractedData.RemoveAll(x => x == 0);
                var succeeded = extractedData.Count;
                var total = failed + succeeded;

                // calculate result and output
                Console.WriteLine(
                    $"{total} connections attempted, {succeeded} succeeded, {(double)failed / total * 100:0.0}% failure chance");
                if (extractedData.Count == 0)
                    WriteErrorLine("stats unavailable: no successful connection attempts");
                else
                    Console.WriteLine(
                        $"{(realRtt ? "" : "2x ")}round-trip min/avg/max/stddev = {extractedData.Min():0.000}/{extractedData.Average():0.000}/{extractedData.Max():0.000}/{extractedData.StdDev():0.000}ms");
                Console.WriteLine($"time spent: {_stopwatch.Elapsed:c}");
            }
        }
コード例 #12
0
ファイル: GroupByTest.cs プロジェクト: GalaxianDev/framework
 static double?GetStdDev(List <int> list)
 {
     return(list.StdDev());
 }
コード例 #13
0
        // Generate some random data.
        private void goButton_Click(object sender, EventArgs e)
        {
            // Make the values.
            Random rand            = new Random();
            int    numValues       = int.Parse(numValuesTextBox.Text);
            double discardFraction = double.Parse(discardFractionTextBox.Text);

            // Make an array of random values.
            int[] valuesArray = new int[numValues];
            for (int i = 0; i < numValues; i++)
            {
                valuesArray[i] = rand.Next(1, 7) + rand.Next(1, 7);
            }

            // Copy the array into a list.
            List <int> valuesList = new List <int>(valuesArray);

            // Display the values.
            valuesListBox.DataSource = valuesArray;

            // Display the values sorted.
            int[] sortedValues = new int[numValues];
            Array.Copy(valuesArray, sortedValues, numValues);
            Array.Sort(sortedValues);
            sortedValuesListBox.DataSource = sortedValues;

            // Display statistics for the array.
            arrayMinimumTextBox.Text       = valuesArray.Min().ToString("0.00");
            arrayMaximumTextBox.Text       = valuesArray.Max().ToString("0.00");
            arrayMeanTextBox.Text          = valuesArray.Average().ToString("0.00");
            arrayTruncatedMeanTextBox.Text = valuesArray.TruncatedMean(0.1).ToString("0.00");
            arrayMedianTextBox.Text        = valuesArray.Median().ToString("0.00");
            arrayModeTextBox.Text          = string.Join(" ",
                                                         valuesArray.Modes().ConvertAll(i => i.ToString()));
            arrayStddevSampleTextBox.Text     = valuesArray.StdDev(true).ToString("0.00");
            arrayStddevPopulationTextBox.Text = valuesArray.StdDev(false).ToString("0.00");

            // Display statistics for the list.
            listMinimumTextBox.Text       = valuesList.Min().ToString("0.00");
            listMaximumTextBox.Text       = valuesList.Max().ToString("0.00");
            listMeanTextBox.Text          = valuesList.Average().ToString("0.00");
            listTruncatedMeanTextBox.Text = valuesArray.TruncatedMean(discardFraction).ToString("0.00");
            listMedianTextBox.Text        = valuesList.Median().ToString("0.00");
            listModeTextBox.Text          = string.Join(" ",
                                                        valuesList.Modes().ConvertAll(i => i.ToString()));
            listStddevSampleTextBox.Text     = valuesList.StdDev(true).ToString("0.00");
            listStddevPopulationTextBox.Text = valuesList.StdDev(false).ToString("0.00");

            // Make a simple histogram.
            Label[] labels = { lbl2, lbl3, lbl4, lbl5, lbl6, lbl7, lbl8, lbl9, lbl10, lbl11, lbl12 };

            // Count the values.
            int[] counts = new int[13];
            for (int i = 0; i < numValues; i++)
            {
                counts[valuesList[i]]++;
            }

            // Scale the bars.
            int   bottom = lbl2.Bottom;
            float scale  = (lbl2.Bottom - numValuesTextBox.Top) / (float)counts.Max();

            for (int i = 0; i < labels.Length; i++)
            {
                labels[i].Height = (int)(counts[i + 2] * scale);
                labels[i].Top    = bottom - labels[i].Height;
            }
        }
コード例 #14
0
        private ResultsGroup AverageResultsGroup(List<ResultsGroup> combiningRows)
        {
            List<Int32> NumChargeStates = new List<int>();
            List<Double> ScanDensity= new List<Double>() ;
            List<Double> NumModiStates= new List<Double>() ;
            List<Double> TotalVolume= new List<Double>() ;
            List<Double> ExpectedA= new List<Double>() ;
            List<Double> Score= new List<Double>() ;
            List<Double> CentroidScan= new List<Double>() ;
            List<Double> NumScan= new List<Double>() ;
            List<Double> AvgSigNoise= new List<Double>() ;
            //These are for calculating the features
            List<Int32> MaxScanNum= new List<int>() ;
            List<Int32> MinScanNum= new List<int>() ;
            List<Int32> ScanNums= new List<int>() ;
            List<Int32> ChargeStateList = new List<int>();
            List<Double> AvgSigNoiseList= new List<Double>() ;
            List<Double> CentroidScanLR= new List<Double>() ;
            List<Double> AvgAA2List= new List<Double>() ;
            List<Double> RelativeTotalVolume = new List<double>();

            List<Int32> scan_num = new List<Int32>();
            List<Int32> charge = new List<Int32>();
            List<Int32> abundance = new List<Int32>();
            List<Double> mz = new List<Double>();
            List<Double> fit = new List<Double>();
            List<Double> average_mw = new List<Double>();
            List<Double> monoisotopic_mw = new List<Double>();
            List<Double> mostabundant_mw = new List<Double>();
            List<Double> fwhm = new List<Double>();
            List<Double> signal_noise = new List<Double>();
            List<Int32> mono_abundance = new List<Int32>();
            List<Int32> mono_plus2_abundance = new List<Int32>();
            List<Int32> flag = new List<Int32>();
            List<Double> interference_sore = new List<Double>();

            ResultsGroup FinalAns = new ResultsGroup();
            FinalAns.ListOfOriginalTotalVolumes = combiningRows[0].ListOfOriginalTotalVolumes;

            for (int i = 0; i < combiningRows.Count(); i++)
            {
                NumChargeStates.Add(combiningRows[i].NumChargeStates);
                ScanDensity.Add(combiningRows[i].ScanDensity);
                NumModiStates.Add(combiningRows[i].NumModiStates);
                TotalVolume.Add(combiningRows[i].TotalVolume);
                ExpectedA.Add(combiningRows[i].ExpectedA);
                Score.Add(combiningRows[i].Score);
                CentroidScan.Add(combiningRows[i].CentroidScan);
                NumScan.Add(combiningRows[i].NumOfScan);
                AvgSigNoise.Add(combiningRows[i].AvgSigNoise);
                //These are for calculating the features
                MaxScanNum.Add(combiningRows[i].MaxScanNum);
                MinScanNum.Add(combiningRows[i].MinScanNum);
                CentroidScanLR.Add(combiningRows[i].CentroidScanLR);
                AvgAA2List.AddRange(combiningRows[i].AvgAA2List);
                RelativeTotalVolume.Add(combiningRows[i].RelativeTotalVolume);

                charge.Add(combiningRows[i].DeconRow.charge);
                scan_num.Add(combiningRows[i].DeconRow.ScanNum);
                abundance.Add(combiningRows[i].DeconRow.abundance);
                mz.Add(combiningRows[i].DeconRow.mz);
                fit.Add(combiningRows[i].DeconRow.fit);
                average_mw.Add(combiningRows[i].DeconRow.average_mw);
                monoisotopic_mw.Add(combiningRows[i].DeconRow.MonoisotopicMassWeight);
                mostabundant_mw.Add(combiningRows[i].DeconRow.mostabundant_mw);
                fwhm.Add(combiningRows[i].DeconRow.fwhm);
                signal_noise.Add(combiningRows[i].DeconRow.SignalNoiseRatio);
                mono_abundance.Add(combiningRows[i].DeconRow.MonoisotopicAbundance);
                mono_plus2_abundance.Add(combiningRows[i].DeconRow.MonoisotopicPlus2Abundance);
                flag.Add(combiningRows[i].DeconRow.flag);
                interference_sore.Add(combiningRows[i].DeconRow.interference_sore);
                for (int h = 0; h < combiningRows[i].ListOfOriginalTotalVolumes.Count(); h++)
                {
                    if (combiningRows[i].ListOfOriginalTotalVolumes[h] > FinalAns.ListOfOriginalTotalVolumes[h])
                    {
                        FinalAns.ListOfOriginalTotalVolumes[h] = combiningRows[i].ListOfOriginalTotalVolumes[h];
                    }
                }

            }

            FinalAns.DeconRow = new DeconRow();
            FinalAns.PredictedComposition = combiningRows[0].PredictedComposition;
            FinalAns.NumChargeStates = Convert.ToInt32(NumChargeStates.Average());
            FinalAns.ScanDensity = ScanDensity.Average();
            FinalAns.NumModiStates = NumModiStates.Average();
            FinalAns.TotalVolume = TotalVolume.Average();
            FinalAns.ExpectedA = ExpectedA.Average();
            FinalAns.Score = Score.Average();
            FinalAns.CentroidScan = CentroidScan.Average();
            FinalAns.NumOfScan = NumScan.Average();
            FinalAns.AvgSigNoise = AvgSigNoise.Average();
            FinalAns.MaxScanNum = Convert.ToInt32(MaxScanNum.Average());
            FinalAns.MinScanNum = Convert.ToInt32(MinScanNum.Average());
            FinalAns.CentroidScanLR = CentroidScanLR.Average();
            FinalAns.TotalVolumeSD = TotalVolume.StdDev();
            FinalAns.RelativeTotalVolumeSD = RelativeTotalVolume.StdDev();
            FinalAns.AvgAA2List = new List<double>();
            FinalAns.AvgAA2List.Add(AvgAA2List.Average());
            FinalAns.RelativeTotalVolume = RelativeTotalVolume.Average();

            FinalAns.DeconRow.ScanNum = Convert.ToInt32(scan_num.Average());
            FinalAns.DeconRow.abundance = Convert.ToInt32(abundance.Average());
            FinalAns.DeconRow.mz = mz.Average();
            FinalAns.DeconRow.fit = fit.Average();
            FinalAns.DeconRow.average_mw = average_mw.Average();
            FinalAns.DeconRow.MonoisotopicMassWeight = monoisotopic_mw.Average();
            FinalAns.DeconRow.mostabundant_mw = mostabundant_mw.Average();
            FinalAns.DeconRow.fwhm = fwhm.Average();
            FinalAns.DeconRow.SignalNoiseRatio = signal_noise.Average();
            FinalAns.DeconRow.MonoisotopicAbundance = Convert.ToInt32(mono_abundance.Average());
            FinalAns.DeconRow.MonoisotopicPlus2Abundance = Convert.ToInt32(mono_plus2_abundance.Average());
            FinalAns.DeconRow.flag = Convert.ToInt32(flag.Average());
            FinalAns.DeconRow.interference_sore = interference_sore.Average();

            return FinalAns;
        }
コード例 #15
0
        public decimal CalcEnsembleError(Star target, List <Star> comparables)
        {
            List <PointD> ensembledev = new List <PointD>();

            foreach (Star comparable in comparables)
            {
                List <decimal> controldmag = new List <decimal>();
                for (int i = 0; i < comparable.Samples.Count; i++)
                {
                    // Calculate control for RMS-
                    decimal controlaverage = comparables.Where(x => x.Name != comparable.Name).Average(x => x.Samples[i].InstrumentalVMag);

                    controldmag.Add(comparable.Samples[i].InstrumentalVMag - controlaverage);
                }
                ensembledev.Add(new PointD(Math.Abs(1.0 / ((double)target.AvgInstrumentalMag - (double)comparable.AvgInstrumentalMag)), (double)controldmag.StdDev()));
            }

            // Calculate weighted deviation - weight is the difference in instrumental mag between the target and comparable.
            return(target.EnsembleError);
        }