Example #1
0
        public void StartTestChangeST()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = grid.ActualWidth;
            var height = grid.ActualHeight;

            const int step   = 20;
            var       labels = new TextBlock[step * 2];

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            var texts = new string[] { "dOpe", "Dope", "doPe", "dopE" };

            Action loop = null;

            loop = () =>
            {
                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }

                var now = sw.ElapsedMilliseconds;

                //60hz, 16ms to build the frame
                while (sw.ElapsedMilliseconds - now < 16)
                {
                    if (processed > max)
                    {
                        (absolute.Children[processed % max] as TextBlock).Text = texts[(int)Math.Floor(rand.NextDouble() * 4)];
                    }
                    else
                    {
                        var label = new TextBlock()
                        {
                            Text       = "Dope",
                            Foreground = new SolidColorBrush(Color.FromArgb(0xFF, (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255)))
                        };

                        label.RenderTransform = new RotateTransform()
                        {
                            Angle = rand.NextDouble() * 360
                        };

                        Canvas.SetLeft(label, rand.NextDouble() * width);
                        Canvas.SetTop(label, rand.NextDouble() * height);

                        absolute.Children.Add(label);
                    }

                    processed++;

                    if (sw.ElapsedMilliseconds - prevMs > 500)
                    {
                        var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                        prevTicks     = sw.ElapsedTicks;
                        prevProcessed = processed;

                        if (processed > max)
                        {
                            dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                            avgSum    += r;
                            avgN++;
                        }

                        prevMs = sw.ElapsedMilliseconds;
                    }
                }

                _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => loop());
            };

            sw.Start();

            _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => loop());
        }
Example #2
0
        void StartTestReuseST()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = absolute.ActualWidth;
            var height = absolute.ActualHeight;

            const int step   = 20;
            var       labels = new TextBlock[step * 2];

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            Action loop = null;

            Stack <TextBlock> _cache = new Stack <TextBlock>();

            loop = () =>
            {
                var now = sw.ElapsedMilliseconds;

                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }

                //60hz, 16ms to build the frame
                while (sw.ElapsedMilliseconds - now < 16)
                {
                    var label = _cache.Count == 0 ? new TextBlock()
                    {
                        Foreground = new SolidColorBrush()
                    } : _cache.Pop();

                    label.Text = "Dope";
                    (label.Foreground as SolidColorBrush).Color = Color.FromArgb(0xFF, (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255));

                    label.RenderTransform = new RotateTransform()
                    {
                        Angle = rand.NextDouble() * 360
                    };

                    Canvas.SetLeft(label, rand.NextDouble() * width);
                    Canvas.SetTop(label, rand.NextDouble() * height);

                    if (processed > max)
                    {
                        _cache.Push(absolute.Children[0] as TextBlock);
                        absolute.Children.RemoveAt(0);
                    }

                    absolute.Children.Add(label);

                    processed++;

                    if (sw.ElapsedMilliseconds - prevMs > 500)
                    {
                        var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                        prevTicks     = sw.ElapsedTicks;
                        prevProcessed = processed;

                        if (processed > max)
                        {
                            dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                            avgSum    += r;
                            avgN++;
                        }

                        prevMs = sw.ElapsedMilliseconds;
                    }
                }

                _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => loop());
            };

            sw.Start();

            _ = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () => loop());
        }
Example #3
0
        //void StartTestGridST()
        //{
        //    var rand = new Random2(0);

        //    breakTest = false;

        //    var width = grid.Width;
        //    var height = grid.Height;

        //    const int step = 20;
        //    var labels = new Label[step * 2];

        //    var processed = 0;

        //    long prevTicks = 0;
        //    long prevMs = 0;
        //    int prevProcessed = 0;
        //    double avgSum = 0;
        //    int avgN = 0;
        //    var sw = new Stopwatch();

        //    Action loop = null;

        //    loop = () =>
        //    {
        //        if (breakTest)
        //        {
        //            var avg = avgSum / avgN;
        //            dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
        //            return;
        //        }

        //        var now = sw.ElapsedMilliseconds;

        //        //60hz, 16ms to build the frame
        //        while (sw.ElapsedMilliseconds - now < 16)
        //        {
        //            var label = new Label()
        //            {
        //                Text = "Dope",
        //                TextColor = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()),
        //                Rotation = rand.NextDouble() * 360,
        //                TranslationX = rand.NextDouble() * width,
        //                TranslationY = rand.NextDouble() * height
        //            };


        //            if (processed > max)
        //            {
        //                grid.Children.RemoveAt(0);
        //            }

        //            grid.Children.Add(label);

        //            processed++;

        //            if (sw.ElapsedMilliseconds - prevMs > 500)
        //            {

        //                var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
        //                prevTicks = sw.ElapsedTicks;
        //                prevProcessed = processed;

        //                if (processed > max)
        //                {
        //                    dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
        //                    avgSum += r;
        //                    avgN++;
        //                }

        //                prevMs = sw.ElapsedMilliseconds;
        //            }
        //        }

        //        Device.BeginInvokeOnMainThread(loop);
        //    };

        //    sw.Start();

        //    Device.BeginInvokeOnMainThread(loop);
        //}

        void StartTestBindings()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = absolute.ActualWidth;
            var height = absolute.ActualHeight;

            const int step   = 20;
            var       labels = new TextBlock[step * 2];

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            var source = Enumerable.Range(0, max).Select(i => new BindingItem()
            {
                Color = Colors.Red
            }).ToArray();

            items.ItemsSource = source;

            Action loop    = null;
            var    current = 0;

            loop = () =>
            {
                var now = sw.ElapsedMilliseconds;

                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }

                //60hz, 16ms to build the frame
                while (sw.ElapsedMilliseconds - now < 16)
                {
                    var index = current++ % source.Length;

                    source[index].Color    = Color.FromArgb(0xFF, (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255));
                    source[index].Rotation = rand.NextDouble() * 360;
                    source[index].Top      = rand.NextDouble() * height;
                    source[index].Left     = rand.NextDouble() * width;

                    processed++;

                    if (sw.ElapsedMilliseconds - prevMs > 500)
                    {
                        var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                        prevTicks     = sw.ElapsedTicks;
                        prevProcessed = processed;

                        if (processed > max)
                        {
                            dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                            avgSum    += r;
                            avgN++;
                        }

                        prevMs = sw.ElapsedMilliseconds;
                    }
                }

                _ = Dispatcher.RunIdleAsync(_ => loop());
            };

            sw.Start();

            _ = Dispatcher.RunIdleAsync(_ => loop());
        }
Example #4
0
        void StartTest()
        {
            VmLocator.OnlineDb.SendPageHit("dopeStart");

            var rand = new Random2(0);

            breakTest = false;

            var width  = absolute.Width;
            var height = absolute.Height;

            retry.IsVisible = back.IsVisible = false;
            stop.IsVisible  = true;

            const int max = 600;

            absolute.Children.Clear();

            var i         = 0;
            var processed = 0;

            var thread = new Thread(() =>
            {
                while (true)
                {
                    if (processed < i - 20)
                    {
                        Thread.Sleep(1);
                        continue;
                    }

                    var label = new Label()
                    {
                        Text      = "Dope",
                        TextColor = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()),
                        Rotation  = rand.NextDouble() * 360
                    };

                    AbsoluteLayout.SetLayoutFlags(label, AbsoluteLayoutFlags.PositionProportional);
                    AbsoluteLayout.SetLayoutBounds(label, new Rectangle(rand.NextDouble(), rand.NextDouble(), 80, 24));

                    absolute.Dispatcher.BeginInvokeOnMainThread(() =>
                    {
                        if (i > max)
                        {
                            absolute.Children.RemoveAt(0);
                        }

                        absolute.Children.Add(label);

                        processed++;
                    });

                    if (breakTest)
                    {
                        break;
                    }

                    i++;
                }

                Device.BeginInvokeOnMainThread(() =>
                {
                    stop.IsVisible  = false;
                    retry.IsVisible = back.IsVisible = true;
                });
            });

            thread.IsBackground = true;
            thread.Priority     = ThreadPriority.Lowest;
            thread.Start();

            var sw = new Stopwatch();

            sw.Start();
            long   prevTicks     = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;

            Device.StartTimer(TimeSpan.FromMilliseconds(500), () =>
            {
                if (retry.IsVisible)
                {
                    var avg    = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    VmLocator.OnlineDb.SendPageHit("dopeAvg", avg.ToString("0.00", new NumberFormatInfo()
                    {
                        NumberDecimalSeparator = "."
                    }));
                    return(false);
                }

                var r         = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                dopes.Text    = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                prevTicks     = sw.ElapsedTicks;
                prevProcessed = processed;

                if (i > max)
                {
                    avgSum += r;
                    avgN++;
                }

                return(true);
            });
        }
Example #5
0
        public void LoadData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents,
                             ProcessInfo processInfo)
        {
            int nrows       = param.GetParam <int>("Number of rows").Value;
            int ncols       = param.GetParam <int>("Number of columns").Value;
            int missingPerc = param.GetParam <int>("Percentage of missing values").Value;
            int ngroups     = param.GetParam <int>("Number of groups").Value;
            ParameterWithSubParams <bool> setSeed = param.GetParamWithSubParams <bool>("Set seed");
            Random2 randy = setSeed.Value? new Random2(setSeed.GetSubParameters().GetParam <int>("Seed").Value) : new Random2();

            ngroups    = Math.Min(ngroups, ncols);
            float[,] m = new float[nrows, ncols];
            ParameterWithSubParams <int> x = param.GetParamWithSubParams <int>("Mode");
            Parameters        subParams    = x.GetSubParameters();
            List <string>     catColNames  = new List <string>();
            List <string[][]> catCols      = new List <string[][]>();

            switch (x.Value)
            {
            case 0:
                for (int i = 0; i < m.GetLength(0); i++)
                {
                    for (int j = 0; j < m.GetLength(1); j++)
                    {
                        if (randy.NextDouble() * 100 < missingPerc)
                        {
                            m[i, j] = float.NaN;
                        }
                        else
                        {
                            m[i, j] = (float)randy.NextGaussian();
                        }
                    }
                }
                break;

            case 1:
                float      dist = (float)subParams.GetParam <double>("Distance").Value;
                string[][] col  = new string[m.GetLength(0)][];
                for (int i = 0; i < m.GetLength(0); i++)
                {
                    bool which = randy.NextDouble() < 0.5;
                    for (int j = 0; j < m.GetLength(1); j++)
                    {
                        if (randy.NextDouble() * 100 < missingPerc)
                        {
                            m[i, j] = float.NaN;
                        }
                        else
                        {
                            m[i, j] = (float)randy.NextGaussian();
                        }
                    }
                    if (which)
                    {
                        m[i, 0] += dist;
                        col[i]   = new[] { "Group1" };
                    }
                    else
                    {
                        col[i] = new[] { "Group2" };
                    }
                }
                catColNames.Add("Grouping");
                catCols.Add(col);
                break;

            case 2:
                double     boxLen  = subParams.GetParam <double>("Box size").Value;
                int        howMany = subParams.GetParam <int>("How many").Value;
                string[][] col1    = new string[m.GetLength(0)][];
                float[,] centers = new float[howMany, m.GetLength(1)];
                for (int i = 0; i < centers.GetLength(0); i++)
                {
                    for (int j = 0; j < centers.GetLength(1); j++)
                    {
                        centers[i, j] = (float)(randy.NextDouble() * boxLen);
                    }
                }
                for (int i = 0; i < m.GetLength(0); i++)
                {
                    int which = (int)(randy.NextDouble() * howMany);
                    for (int j = 0; j < m.GetLength(1); j++)
                    {
                        if (randy.NextDouble() * 100 < missingPerc)
                        {
                            m[i, j] = float.NaN;
                        }
                        else
                        {
                            m[i, j] = (float)randy.NextGaussian() + centers[which, j];
                        }
                    }
                    col1[i] = new[] { "Group" + (which + 1) };
                }
                catColNames.Add("Grouping");
                catCols.Add(col1);
                break;
            }
            List <string> exprColumnNames = new List <string>();

            for (int i = 0; i < ncols; i++)
            {
                exprColumnNames.Add("Column " + (i + 1));
            }
            mdata.Name        = "Random matrix";
            mdata.ColumnNames = exprColumnNames;
            mdata.Values.Set(m);
            mdata.Quality.Set(new float[m.GetLength(0), m.GetLength(1)]);
            mdata.IsImputed.Set(new bool[m.GetLength(0), m.GetLength(1)]);
            mdata.SetAnnotationColumns(new List <string>(), new List <string[]>(), catColNames, catCols, new List <string>(),
                                       new List <double[]>(), new List <string>(), new List <double[][]>());
            mdata.Origin = "Random matrix";
            string[] names = new string[mdata.RowCount];
            for (int i = 0; i < names.Length; i++)
            {
                names[i] = "Row " + (i + 1);
            }
            mdata.AddStringColumn("Name", "Name", names);
            string[][] grouping = new string[ncols][];
            for (int i = 0; i < ncols; i++)
            {
                int ig = (i * ngroups) / ncols + 1;
                grouping[i] = new[] { "Group" + ig };
            }
            mdata.AddCategoryRow("Grouping", "Grouping", grouping);
        }
Example #6
0
        void StartTestChangeST()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = grid.Width;
            var height = grid.Height;

            const int step   = 20;
            var       labels = new Label[step * 2];

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            var texts = new string[] { "dOpe", "Dope", "doPe", "dopE" };

            Action loop = null;

            loop = () =>
            {
                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }


                var now = sw.ElapsedMilliseconds;

                //60hz, 16ms to build the frame
                while (sw.ElapsedMilliseconds - now < 16)
                {
                    var label = new Label()
                    {
                        Text      = "Dope",
                        TextColor = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()),
                        Rotation  = rand.NextDouble() * 360
                    };

                    AbsoluteLayout.SetLayoutFlags(label, AbsoluteLayoutFlags.PositionProportional);
                    AbsoluteLayout.SetLayoutBounds(label, new Rectangle(rand.NextDouble(), rand.NextDouble(), 80, 24));

                    if (processed > max)
                    {
                        (absolute.Children[processed % max] as Label).Text = texts[(int)Math.Floor(rand.NextDouble() * 4)];
                    }
                    else
                    {
                        absolute.Children.Add(label);
                    }

                    processed++;

                    if (sw.ElapsedMilliseconds - prevMs > 500)
                    {
                        var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                        prevTicks     = sw.ElapsedTicks;
                        prevProcessed = processed;

                        if (processed > max)
                        {
                            dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                            avgSum    += r;
                            avgN++;
                        }

                        prevMs = sw.ElapsedMilliseconds;
                    }
                }

                Device.BeginInvokeOnMainThread(loop);
            };

            sw.Start();

            Device.BeginInvokeOnMainThread(loop);
        }
Example #7
0
        void StartTestGridST()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = grid.Width;
            var height = grid.Height;

            const int step   = 20;
            var       labels = new Label[step * 2];

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            Action loop = null;

            loop = () =>
            {
                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }

                var now = sw.ElapsedMilliseconds;

                //60hz, 16ms to build the frame
                while (sw.ElapsedMilliseconds - now < 16)
                {
                    var label = new Label()
                    {
                        Text         = "Dope",
                        TextColor    = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()),
                        Rotation     = rand.NextDouble() * 360,
                        TranslationX = rand.NextDouble() * width,
                        TranslationY = rand.NextDouble() * height
                    };


                    if (processed > max)
                    {
                        grid.Children.RemoveAt(0);
                    }

                    grid.Children.Add(label);

                    processed++;

                    if (sw.ElapsedMilliseconds - prevMs > 500)
                    {
                        var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                        prevTicks     = sw.ElapsedTicks;
                        prevProcessed = processed;

                        if (processed > max)
                        {
                            dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                            avgSum    += r;
                            avgN++;
                        }

                        prevMs = sw.ElapsedMilliseconds;
                    }
                }

                Device.BeginInvokeOnMainThread(loop);
            };

            sw.Start();

            Device.BeginInvokeOnMainThread(loop);
        }
Example #8
0
        void StartTestMT2()
        {
            var rand = new Random2(0);

            breakTest = false;

            var width  = absolute.Width;
            var height = absolute.Height;

            const int step = 75;

            var processed = 0;

            long   prevTicks     = 0;
            long   prevMs        = 0;
            int    prevProcessed = 0;
            double avgSum        = 0;
            int    avgN          = 0;
            var    sw            = new Stopwatch();

            var bankA = new Label[step];
            var bankB = new Label[step];

            Action <Label[]> addLabels = (Label[] labels) =>
            {
                for (int k = 0; k < step; k++)
                {
                    var label = new Label()
                    {
                        Text      = "Dope",
                        TextColor = new Color(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()),
                        Rotation  = rand.NextDouble() * 360
                    };

                    AbsoluteLayout.SetLayoutFlags(label, AbsoluteLayoutFlags.PositionProportional);
                    AbsoluteLayout.SetLayoutBounds(label, new Rectangle(rand.NextDouble(), rand.NextDouble(), 80, 24));

                    labels[k] = label;
                }
            };

            addLabels(bankA);
            addLabels(bankB);

            var bank = bankA;

            Action loop = null;

            var  i    = 0;
            Task task = null;

            loop = () =>
            {
                if (breakTest)
                {
                    var avg = avgSum / avgN;
                    dopes.Text = string.Format("{0:0.00} Dopes/s (AVG)", avg).PadLeft(21);
                    return;
                }

                if (processed > max)
                {
                    absolute.Children.RemoveAt(0);
                }

                absolute.Children.Add(bank[i]);
                i++;

                if (i == step)
                {
                    if (task != null && task.Status != TaskStatus.RanToCompletion)
                    {
                        task.Wait();
                    }
                    task = Task.Run(() => addLabels(bank));
                    if (bank == bankA)
                    {
                        bank = bankB;
                    }
                    else
                    {
                        bank = bankA;
                    }
                    i = 0;
                }

                processed++;

                if (sw.ElapsedMilliseconds - prevMs > 500)
                {
                    var r = (double)(processed - prevProcessed) / ((double)(sw.ElapsedTicks - prevTicks) / Stopwatch.Frequency);
                    prevTicks     = sw.ElapsedTicks;
                    prevProcessed = processed;

                    if (processed > max)
                    {
                        dopes.Text = string.Format("{0:0.00} Dopes/s", r).PadLeft(15);
                        avgSum    += r;
                        avgN++;
                    }

                    prevMs = sw.ElapsedMilliseconds;
                }

                Device.BeginInvokeOnMainThread(loop);
            };

            sw.Start();


            Device.BeginInvokeOnMainThread(loop);
        }