Esempio n. 1
0
        private static void GetSort(string sortName, AlgorithmBase <int> baseSort, IEnumerable <int> items)
        {
            var stopwatch = new Stopwatch();

            baseSort.Items.AddRange(items);
            stopwatch.Start();
            baseSort.Sort();
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("{0}:\nSwopCount:{2} {1}", sortName, stopwatch.Elapsed, baseSort.SwopCount);
            stopwatch.Stop();
            foreach (var item in baseSort.Items)
            {
                Console.Write("{0} ", item);
            }
        }
Esempio n. 2
0
        public void BaseSortTest()
        {
            //arrange
            var bases = new AlgorithmBase <int>();

            bases.Items.AddRange(items);

            //act
            bases.Sort();

            //assert
            for (int i = 0; i < items.Count; i++)
            {
                Assert.AreEqual(sorted[i], bases.Items[i]);
            }
        }
Esempio n. 3
0
        private void Btn_Click(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();
            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPosition(i);
            }
            panel5.Refresh();
            algorithm.CompareEvent += AlgorithmCompareEvent;
            algorithm.SwapEvent    += AlgorithmSwapEvent;
            algorithm.SetEvent     += AlgorithmSetEvent;
            var time = algorithm.Sort();

            TimeLabel.Text    = "Time: " + time.Seconds;
            SwapLabel.Text    = "Qty swaps: " + algorithm.SwapCount;
            CompareLabel.Text = "Qty comparisons: " + algorithm.CompareCount;
        }
Esempio n. 4
0
        public void StartSorting(AlgorithmBase <SortedItem> listForSort)
        {
            panel4.Controls.Add(ComparisonLabel);
            panel4.Controls.Add(SwopLabel);
            TimeLabel.Text = "Время: ";
            panel4.Controls.Add(TimeLabel);

            listForSort.CompareEvent += ListForSort_CompareEvent;
            listForSort.SwopEvent    += ListForSort_SwopEventAsync;
            panel4.Refresh();

            var time = listForSort.Sort();

            TimeLabel.Text += $"{time.Seconds}";
            //SwopLabel.Text += listForSort.SwopCount;
            //ComparisonLabel.Text += listForSort.ComparisonCount;
        }
Esempio n. 5
0
        private void Btn_Click(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();
            for (int i = 0; i < algorithm.Items.Count; i++)//решение heapSort
            {
                algorithm.Items[i].SetPosition(i);
            }
            panel3.Refresh();
            algorithm.CompareEvent += Algorithm_CompareEvent;
            algorithm.SwapEvent    += Algorithm_SwapEvent;
            algorithm.SetEvent     += Algorithm_SetEvent;
            var time = algorithm.Sort();

            TimeLabel.Text    = "Время:" + time.Milliseconds + " ms";
            SwapLabel.Text    = "Колличество обменов:" + algorithm.SwapCount;
            CompareLabel.Text = "Колличество сравнений:" + algorithm.ComparisonCount;
        }
        private void BtnClick(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();
            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPosition(i);
            }
            panel3.Refresh();

            algorithm.CompareEvent += AlgorithmCompareEvent;
            algorithm.SwopEvent    += AlgorithmSwopEvent;
            algorithm.SetEvent     += AlgoritmSetEvent;
            var time = algorithm.Sort();

            TimeLbl.Text    = "Время: " + time.Seconds;
            SwopLbl.Text    = "Количество обменов: " + algorithm.SwopCount;
            CompareLbl.Text = "Количество сравнений: " + algorithm.ComparisonCount;
        }
Esempio n. 7
0
        private static double MeasureQuickGraphAlgorithmSpeed <TVertex, TEdge>(
            AlgorithmBase <IVertexListGraph <TVertex, TEdge> > algorithm, int iterationNum = 10)
            where TEdge : IEdge <TVertex>
        {
            Stopwatch sw = new Stopwatch();

            for (int i = 0; i < iterationNum; i++)
            {
                sw.Start();
                algorithm.Compute();
                sw.Stop();
                Console.WriteLine("Iteration " + i);
            }
            var elapsedMs = sw.ElapsedMilliseconds / (double)iterationNum;

            Console.WriteLine("QuickGraph: " + elapsedMs + " ms");
            return(elapsedMs);
        }
Esempio n. 8
0
        private async Task <int> RunAlgorithm(int Index)
        {
            await Task.FromResult(0);

            AlgorithmBase algorithm = Context.Algorithms[Index].Algorithm;

            algorithm.Calculate();

            StablePairsEvaluation          stablePairsEvaluation          = new StablePairsEvaluation();
            GroupHappinessEvaluation       groupHappinessEvaluation       = new GroupHappinessEvaluation();
            EgalitarianHappinessEvaluation egalitarianHappinessEvaluation = new EgalitarianHappinessEvaluation();

            AlgorithmFinished?.Invoke(this, new AlgorithmEventArgs(Index,
                                                                   algorithm.Evaluate(stablePairsEvaluation),
                                                                   algorithm.Evaluate(groupHappinessEvaluation),
                                                                   algorithm.Evaluate(egalitarianHappinessEvaluation)));
            return(Index);
        }
Esempio n. 9
0
        private void BtnSortClick(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();

            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPosition(i);
            }

            panel3.Refresh();

            algorithm.CompareEvent += Algoritm_CompareEvent;
            algorithm.SwapEvent    += Algoritm_SwapEvent;
            var time = algorithm.Sort();

            timeLabel.Text    = "Время: " + time.Seconds;
            compareLabel.Text = "Количество сравнений: " + algorithm.ComprisonCount;
            swapLabel.Text    = "Количество обменов " + algorithm.SwapCount;
        }
Esempio n. 10
0
        private void BtnClick(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();

            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPosition(i);
            }

            algorithm.CompareEvent += AlgorithmCompareEvent;
            algorithm.SwopEvent    += AlgorithmSwopEvent;
            algorithm.SetEvent     += AlgorithmSetEvent;

            var time = algorithm.Sort();

            lblTime.Text       = $"Время выполнения: {time.Milliseconds} мс";
            lblComparison.Text = $"Количество сравнений: {algorithm.ComparisonCount}";
            lblSwop.Text       = $"Количество обменов: {algorithm.SwopCount}";
        }
Esempio n. 11
0
        private void BtnClick(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();

            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPos(i);
            }
            panel3.Refresh();

            algorithm.CompareEvent += Algorithm_CompareEvent;
            algorithm.SwapEvent    += Algorithm_SwapEvent;
            algorithm.SetEvent     += AlgorithmSetEvent;
            var time = algorithm.Sort();

            Time.Text    = "Time: " + time.Seconds;
            Swap.Text    = "Number swap: " + algorithm.SwapCount;
            Compare.Text = "Number comparison: " + algorithm.CompareCount;
        }
Esempio n. 12
0
        private void BttnSort_Click(AlgorithmBase <SortedItem> algorithm)
        {
            RefreshItems();

            for (int i = 0; i < algorithm.Items.Count; i++)
            {
                algorithm.Items[i].SetPosition(i);
            }

            VisualizationPanel.Refresh();

            algorithm.CompareEvent += AlgorithmCompareEvent;
            algorithm.SwopEvent    += AlgorithmSwopEvent;
            algorithm.SetEvent     += AlgorithmSetEvent;
            var time = algorithm.Sort();

            TimeLabel.Text        = "Time: " + time.Seconds;
            ComparsionsLabel.Text = "Compare: " + algorithm.ComparsionCount;
            SwopsLabel.Text       = "Swops: " + algorithm.ComparsionCount;
        }
Esempio n. 13
0
        private void outputError(AlgorithmBase <double[, , ]> alg)
        {
            Console.WriteLine("Errors:");

            var sample = new ClassifiedSample <double[, , ]>();

            foreach (var obj in Data.Data)
            {
                var data = obj.Key;
                var key  = new double[data.Length, 1, 1];
                for (int i = 0; i < data.Length; i++)
                {
                    key[i, 0, 0] = data[i];
                }
                sample[key] = obj.Value;
            }

            var errors = alg.GetErrors(sample);
            var ec     = errors.Count();
            var dc     = Data.Data.Count;
            var pct    = Math.Round(100.0F * ec / dc, 2);

            Console.WriteLine("{0} of {1} ({2}%)", ec, dc, pct);
        }
Esempio n. 14
0
        /// <summary>
        /// Initialize algorithm according to type by index=<paramref name="algNum"/>
        /// </summary>
        /// <param name="algNum">algorithm type index</param>
        /// <param name="amount">collection size</param>
        private void InitializeAlgorithm(int amount = 0)
        {
            switch (algorithmType)
            {
            case AlgorithmType.BubbleSort:
                if (myOwncollection == null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new BubbleAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new BubbleAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new BubbleAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.CocktailSort:
                if (myOwncollection == null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new CoctailAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new CoctailAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new CoctailAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.InsertionSort:
                if (myOwncollection is null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new InsertionAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new InsertionAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new InsertionAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.ShellSort:
                if (myOwncollection is null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new ShellAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new ShellAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new ShellAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.SelectionSort:
                if (myOwncollection is null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new SelectionAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new SelectionAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new SelectionAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.GnomeSort:
                if (myOwncollection is null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new GnomeAlgorithm();
                    }
                    else
                    {
                        sortAlgorithm = new GnomeAlgorithm(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new GnomeAlgorithm(myOwncollection);
                }
                break;

            case AlgorithmType.BinaryTreeSort:
                if (myOwncollection is null)
                {
                    if (amount <= 0)
                    {
                        sortAlgorithm = new BinaryTree();
                    }
                    else
                    {
                        sortAlgorithm = new BinaryTree(amount);
                    }
                }
                else
                {
                    sortAlgorithm = new BinaryTree(myOwncollection);
                }
                break;

            case AlgorithmType.RadixSort:
                break;

            case AlgorithmType.MergeSort:
                break;

            case AlgorithmType.QuickSort:
                break;

            default:
                throw new WrongAlgExcetion();
            }
        }
Esempio n. 15
0
        private void baseSortButton_Click(object sender, EventArgs e)
        {
            var bases = new AlgorithmBase <SortedItem>(items);

            BtnSortClick(bases);
        }
Esempio n. 16
0
 /// <summary>
 /// Constructor of class to hold current selected algorithm engine
 /// </summary>
 public SurfaceBuilder()
 {
     this.Alg = AlgorithmBase.CreateAlgorithm(AlgorithmBase.Algorithm.BSpline);
 }
Esempio n. 17
0
 public void InitAlgorithmBase(StepSize size)
 {
     StepSize        = size;
     algoBase        = new AlgorithmBase(size);
     CurrentPosition = algoBase.CurrentStep;
 }
Esempio n. 18
0
 public void Generate(AlgorithmBase algorithm)
 {
     algorithm.Apply(this);
 }
Esempio n. 19
0
        private void SortButton_Click(object sender, EventArgs e)
        {
            if (sortedItemsCount > 0)
            {
                (sender as Button).Enabled = false;

                int methods = 1;

                if (SpeedTrackBar.Value == 0)
                {
                    SpeedTrackBar.Enabled = false;
                    methods = allMethods.GetLength(0);
                    VisualPanel.Controls.Clear();
                }

                string methodName = "";
                for (int methodNumber = 1; methodNumber <= methods; methodNumber++)
                {
                    Label label = new Label();
                    AlgorithmBase <SortedItem> algorithm = new AlgorithmBase <SortedItem>();

                    if (SpeedTrackBar.Value > 0)
                    {
                        foreach (RadioButton radioButton in panel3.Controls.OfType <RadioButton>())
                        {
                            if (radioButton.Checked)
                            {
                                if (!Int32.TryParse(radioButton.Name.Substring("radioButton".Length), out methodNumber))
                                {
                                    methodNumber = 1;
                                }
                                break;
                            }
                        }
                    }

                    if (panel3.Controls.Find("radioButton" + methodNumber.ToString(), false).Any())
                    {
                        methodName = panel3.Controls["radioButton" + methodNumber.ToString()].Text;
                    }

                    switch (methodName)
                    {
                    case "Bubble Sort":
                        algorithm = new BubbleSort <SortedItem>();
                        break;

                    case "Cocktail Sort":
                        algorithm = new CocktailSort <SortedItem>();
                        break;

                    case "Insertion Sort":
                        algorithm = new InsertionSort <SortedItem>();
                        break;

                    case "Shell Sort":
                        algorithm = new ShellSort <SortedItem>();
                        break;

                    case "Tree Sort":
                        algorithm = new Algorithm.DataStructures.Tree <SortedItem>();
                        break;

                    case "Heap Sort":
                        algorithm = new Algorithm.DataStructures.Heap <SortedItem>();
                        break;

                    case "Selection Sort":
                        algorithm = new SelectionSort <SortedItem>();
                        break;

                    case "Gnome Sort":
                        algorithm = new GnomeSort <SortedItem>();
                        break;

                    case "Radix Sort":
                        algorithm = new RadixSort <SortedItem>(RadixSortCheckBox.Checked);
                        break;

                    case "Merge Sort":
                        algorithm = new MergeSort <SortedItem>();
                        break;

                    case "Quick Sort":
                        algorithm = new QuickSort <SortedItem>();
                        break;

                    case "Odd-Even Sort":
                        algorithm = new OddEvenSort <SortedItem>();
                        break;

                    case "Comb Sort":
                        algorithm = new CombSort <SortedItem>();
                        break;

                    default:
                        algorithm = new BubbleSort <SortedItem>();
                        break;
                    }
                    //MessageBox.Show("Вы выбрали метод сортировки " + panel3.Controls["radioButton" + methodNumber.ToString()].Text + " : " + methodNumber.ToString());

                    if (SpeedTrackBar.Value > 0)
                    {
                        algorithm.CompareEvent += AlgorithmCompareEvent;
                        algorithm.SwapEvent    += AlgorithmSwapEvent;
                        algorithm.RemoveEvent  += AlgorithmRemoveEvent;
                    }
                    else
                    {
                        int verticalInterval = 15;
                        if (methodNumber > 1 && ((methodNumber - 1) % (VisualPanel.Height / verticalInterval)) == 0)
                        {
                            VisualPanel.Controls.Clear();
                        }
                        label.Name     = "label_" + methodNumber.ToString();
                        label.Text     = "Идет сортировка массива из " + items.Count.ToString() + " элементов по методу " + panel3.Controls["radioButton" + methodNumber.ToString()].Text + " ...";
                        label.AutoSize = true;
                        label.Location = new Point(5, verticalInterval * ((methodNumber - 1) % (VisualPanel.Height / verticalInterval)));
                        VisualPanel.Controls.Add(label);
                        VisualPanel.Refresh();
                    }

                    algorithm.AddRange(items);
                    TimeSpan runTime = algorithm.SortAndGetSpan(!reverseSortCheckBox.Checked);

                    if (SpeedTrackBar.Value == 0)
                    {
                        label.Text = "Сортировка " + items.Count.ToString() + " элементов по методу " + panel3.Controls["radioButton" + methodNumber.ToString()].Text + " завершена.";
                    }
                    else if (methodName == "Heap Sort")
                    {
                        VisualPanel.Controls.Clear();
                        sortedItemsCount = 0;
                        for (int i = 0; i < algorithm.Items.Count; i++)
                        {
                            SortedItem item = new SortedItem(VisualPanel, ++sortedItemsCount, algorithm.Items[i].Value);
                            VisualPanel.Refresh();
                        }
                        VisualPanel.Refresh();
                    }

                    ResultTableLayoutPanel.GetControlFromPosition(methodNumber, 3).Text = runTime.Seconds.ToString() + "." + runTime.Milliseconds.ToString();
                    ResultTableLayoutPanel.GetControlFromPosition(methodNumber, 4).Text = algorithm.ComparisonCount.ToString();
                    ResultTableLayoutPanel.GetControlFromPosition(methodNumber, 5).Text = algorithm.SwapCount.ToString();

                    VisualPanel.Refresh();
                }

                SpeedTrackBar.Enabled = true;

                if (SpeedTrackBar.Value == 0)
                {
                    for (int i = 1; i <= 3; i++)
                    {
                        ResultTableLayoutPanel.Controls["TestsRadioButton_" + i.ToString()].Enabled = true;
                    }
                }
            }
        }
Esempio n. 20
0
 private void ShowInfoAboutSort(AlgorithmBase <int> algorithm, TimeSpan time)
 {
     MessageBox.Show($"Отсортировано за: {time.Milliseconds.ToString()} мс.\n" +
                     $"Количество сравнений: {algorithm.CompareCount}\n" +
                     $"Количество обменов:{algorithm.SwapCount}");
 }
        private bool SetAlgorithmData()
        {
            foreach (RadioButton rb in AlgorithmGroupBox.Controls.OfType <RadioButton>())
            {
                if (rb.Checked)
                {
                    selectedAlgorithm = rb.AccessibleName;
                    break;
                }
            }

            switch (selectedAlgorithm)
            {
            case "Bubble Sort":
                algorithm = new BubbleSort();
                algorithm.SetComplexity(4);
                break;

            case "Merge Sort":
                algorithm = new MergeSort();
                algorithm.SetComplexity(2);
                break;

            case "Insertion Sort":
                algorithm = new InsertionSort();
                algorithm.SetComplexity(4);
                break;

            case "Heap Sort":
                algorithm = new HeapSort();
                algorithm.SetComplexity(0);
                break;

            case "Bogo Sort":
                algorithm = new BogoSort();
                algorithm.timeComplexity  = "O(n*n!)";
                algorithm.spaceComplexity = "O(1)";
                MessageBox.Show("Please Note: Within the 'Bogo Sort', the light blue colouring is used for displaying the original set of elements before the new iteration of sort is shown in black.", "Notice");
                break;

            case "Selection Sort":
                algorithm = new SelectionSort();
                algorithm.SetComplexity(4);
                break;

            case "Quick Sort":
                algorithm = new QuickSort();
                algorithm.SetComplexity(1);
                break;

            case "Cocktail Sort":
                algorithm = new CocktailSort();
                algorithm.SetComplexity(4);
                break;

            case "Radix Sort LSD":
                algorithm = new RadixSort();
                algorithm.SetComplexity(3);
                break;

            case "Shell Sort":
                algorithm = new ShellSort();
                algorithm.SetComplexity(4);
                break;

            case "Comb Sort":
                algorithm = new CombSort();
                algorithm.SetComplexity(4);
                break;

            case "Gnome Sort":
                algorithm = new GnomeSort();
                algorithm.SetComplexity(4);
                break;

            case "OddEven Sort":
                algorithm = new OddEvenSort();
                algorithm.SetComplexity(4);
                break;

            case "Cycle Sort":
                algorithm = new CycleSort();
                algorithm.SetComplexity(4);
                break;

            case "Tree Sort":
                algorithm = new TreeSort();
                algorithm.SetComplexity(2);
                break;

            case "Pancake Sort":
                algorithm = new PancakeSort();
                algorithm.SetComplexity(4);
                break;

            case null:
                MessageBox.Show("Please select an algorithm", "Error");
                return(false);
            }
            return(true);
        }
Esempio n. 22
0
 public static IEnumerable <Type> GetKnownTypes()
 {
     return(AlgorithmBase.GetKnownTypes());
 }