예제 #1
0
 private void Sort()
 {
     //var result = SelectedMethod.Command(array);
     //Document = result.CreateDocument();
     Result   = SelectedMethod.Command(array);
     Document = Result.CreateDocument();
 }
    SortingResult GetSummedResult(List <SortingResult> results)
    {
        SortingResult summedResult = new SortingResult();

        summedResult.averageTimeTaken  = results.Sum(x => x.averageTimeTaken) / results.Count();
        summedResult.isCorrectlySorted = results.TrueForAll(x => x.isCorrectlySorted);
        summedResult.sortingName       = results[0].sortingName;
        return(summedResult);
    }
예제 #3
0
        // Denne metode kaldes udefra når vi gerne vil bruge bubblesort, metoden er statisk da vi ikke er interesseret i at dem der bruger biblioteket skal instantiate en klasse, når det er et bibliotek
        public static SortingResult BubbleSort(int[] _unsortedArr)
        {
            Files         file   = new Files("bubblesort"); // Vi kalder på vores fil bibliotek og laver en ny fil ved navn bubblesort
            SortingResult result = new SortingResult();     // Vi laver et nyt sortingsresultat

            timer.Interval = 200;                           // We sætter en timer til at ticke hver 200 milisekund
            timer.Start();                                  // Vi starter timeren
            // Vi abonnerer på et OnTimer_Tick event og passerer vores resultat og fil så vi kan skrive til filen.
            timer.Elapsed += (sender, e) => OnTimer_Tick(sender, e, result, file);

            // Dette nestede for loop sørger for at vi kører det hele igennem, hvis der kun var et for loop ville der kun foregå en iteration med modifikationer
            for (int j = 0; j < _unsortedArr.Length; j++)
            {
                for (int i = 0; i < _unsortedArr.Length - 1 - j; i++)
                {
                    result.checks++; // Vi har lige kigget på et element

                    // Hvis det tal vi kigger på er større end det næste tal
                    if (_unsortedArr[i] > _unsortedArr[i + 1])
                    {
                        // Vi skal nu lave en modifikation
                        result.modifications++;
                        // Byt da rundt på deres pladser
                        int temp = _unsortedArr[i];
                        _unsortedArr[i]     = _unsortedArr[i + 1];
                        _unsortedArr[i + 1] = temp;
                    }
                }
            }

            // Vi stopper timeren, fjerner abonnentet fra eventet OnTimer_Tick, samt gemmer vores fil
            timer.Stop();
            result.time.Stop();
            timer.Elapsed -= (sender, e) => OnTimer_Tick(sender, e, result, file);
            file.SaveFile();
            result.sortedArr = _unsortedArr;
            return(result); // Til sidst returnerer vi result som er af typen SortingResult
        }
예제 #4
0
        public static SortingResult MergeSort(int[] _unsortedArr)
        {
            Files         file   = new Files("mergesort");
            SortingResult result = new SortingResult();

            timer.Interval = 200;
            timer.Start();
            timer.Elapsed += (sender, e) => OnTimer_Tick(sender, e, result, file);

            // Vi begynder at splitte vores array
            result.sortedArr = split(_unsortedArr);

            timer.Stop();
            timer.Elapsed -= (sender, e) => OnTimer_Tick(sender, e, result, file);
            file.SaveFile();
            result.time.Stop();
            return(result);

            int[] split(int[] _unsplitArray)
            {
                if (_unsplitArray.Length <= 1)
                {
                    return(_unsplitArray);                           // Hvis vi modtager et array som har en længde der er mindre end 1 er der ikke noget at sortere
                }
                // Med take funktionen kan vi tage de første elementer og ignorere resten
                int[] left = split(_unsplitArray.Take(_unsplitArray.Length / 2).ToArray());
                // Med skip funktionen kan vi tage de sidste elementer og ignorere starten
                int[] right = split(_unsplitArray.Skip(_unsplitArray.Length / 2).ToArray());

                // Vi kalder på merge som sorterer vores array
                return(merge(left, right));
            }

            int[] merge(int[] _left, int[] _right)
            {
                // Vi laver et nyt int array som holder det endelige resultat. Dette vil være både venstre og højresidens længde
                int[] merge_result = new int[_left.Length + _right.Length];

                // Vi har to pointers der peger på det element vi er kommet til i arrayet
                int pointerLeft  = 0;
                int pointerRight = 0;


                // Sorter mens der stadig er noget i begge arrays
                while (_left.Length != pointerLeft && _right.Length != pointerRight)
                {
                    result.checks++; // Vi har nu kigget på et element

                    // Hvis vores venstreside er mindre end vores højreside
                    if (_left[pointerLeft] < _right[pointerRight])
                    {
                        merge_result[pointerLeft + pointerRight] = _left[pointerLeft];
                        pointerLeft++;
                        result.modifications++; // Vi har nu modificeret et element
                    }
                    // Hvis venstre- og højreside er ens
                    else if (_left[pointerLeft] == _right[pointerRight])
                    {
                        merge_result[pointerLeft + pointerRight] = _left[pointerLeft];
                        pointerLeft++;
                        merge_result[pointerLeft + pointerRight] = _right[pointerRight];
                        pointerRight++;
                        result.modifications += 2;
                    }
                    // Hvis vesntresiden er større end højresiden
                    else if (_left[pointerLeft] > _right[pointerRight])
                    {
                        merge_result[pointerLeft + pointerRight] = _right[pointerRight];
                        pointerRight++;
                        result.modifications++;
                    }
                }

                //hvis der kun er tal tilbage i et array skal vi sætte det hele efter det vi har i merge result
                if (_left.Length == pointerLeft)
                {
                    while (pointerRight != _right.Length)
                    {
                        merge_result[pointerLeft + pointerRight] = _right[pointerRight];
                        pointerRight++;
                        result.modifications++;
                    }
                }
                else if (_right.Length == pointerRight)
                {
                    while (pointerLeft != _left.Length)
                    {
                        merge_result[pointerLeft + pointerRight] = _left[pointerLeft];
                        pointerLeft++;
                        result.modifications++;
                    }
                }

                return(merge_result);
            }
        }
예제 #5
0
 public static void OnTimer_Tick(object sender, EventArgs e, SortingResult _result, Files _file)
 {
     // Vi skriver en ny linie til vores fil, hver linie fortæller hvor lang tid der er gået, hvor mange checks vi har lavet samt modifikationer
     _file.WriteNewLine($"{_result.time.ElapsedMilliseconds},{_result.checks},{_result.modifications}");
 }
    private void OnGUI()
    {
        int height = 0;

        GUI.Label(new Rect(10, height += 20, 100, 20), "Radix GPU Sort", EditorStyles.boldLabel);
        compareWithOrderBy             = GUI.Toggle(new Rect(10, height += 20, 300, 20), compareWithOrderBy, "Compare with List.OrderBy");
        compareWithArraySort           = GUI.Toggle(new Rect(10, height += 20, 300, 20), compareWithArraySort, "Compare with Array.Sort");
        //compareWithRandomSort = GUI.Toggle(new Rect(10, height += 20, 300, 20), compareWithRandomSort, "Compare with Random Sort");
        fullSort = GUI.Toggle(new Rect(10, height += 20, 300, 20), fullSort, "Perform Full Sort");
        //saveResultIntoCSV = GUI.Toggle(new Rect(10, height += 20, 300, 20), saveResultIntoCSV, "Save Result Into CSV");

        string sortingCountFieldData = GUI.TextField(new Rect(10, height += 20, 100, 20), sortingCount.ToString());

        sortingCountFieldData = Regex.Replace(sortingCountFieldData, "[^.0-9]", "");
        int.TryParse(sortingCountFieldData, out sortingCount);

        string iterationCountFieldData = GUI.TextField(new Rect(10, height += 20, 100, 20), iterations.ToString());

        iterationCountFieldData = Regex.Replace(iterationCountFieldData, "[^.0-9]", "");
        int.TryParse(iterationCountFieldData, out iterations);

        if (GUI.Button(new Rect(10, height += 20, 100, 20), "Sort"))
        {
            List <Func <float[], SortingResult> > sortsToExecute = new List <Func <float[], SortingResult> >();
            sortsToExecute.Add(PerformRadixSort);

            if (compareWithOrderBy)
            {
                sortsToExecute.Add(PerformOrderBy);
            }

            if (compareWithArraySort)
            {
                sortsToExecute.Add(PerformArraySort);
            }

            if (compareWithRandomSort)
            {
                sortsToExecute.Add(PerformSomeRandomSort);
            }

            float[] sortInput = GenerateRandomValues(sortingCount);

            sortingResults = new List <SortingResult>();

            //for(int i = 1000; i <= sortingCount; i += 1000)
            //{
            //    float[] randomValues = GenerateRandomValues(i);
            //    for (int j = 0; j < sortsToExecute.Count; j++)
            //    {
            //        List<SortingResult> allResultsSingleSort = new List<SortingResult>();

            //        for (int k = 0; k < iterations; k++)
            //            allResultsSingleSort.Add(sortsToExecute[j](randomValues));

            //        sortingResults.Add(GetSummedResult(allResultsSingleSort));
            //    }

            //    if(i == 1000)
            //        WriteCSVRow("Iterations," + string.Join(",", sortingResults.Select(x => x.sortingName).ToArray()));

            //    WriteCSVRow(i + "," + string.Join(",", sortingResults.Select(x => x.averageTimeTaken).ToArray()));

            //    sortingResults.Clear();
            //}

            for (int i = 0; i < sortsToExecute.Count; i++)
            {
                List <SortingResult> allResultsSingleSort = new List <SortingResult>();

                if (!fullSort)
                {
                    for (int j = 0; j < iterations; j++)
                    {
                        allResultsSingleSort.Add(sortsToExecute[i](GenerateRandomValues(sortingCount)));
                    }
                }
                else
                {
                    for (int j = 1; j <= sortingCount; j += UnityEngine.Random.Range(1000, 10000))
                    {
                        allResultsSingleSort.Add(sortsToExecute[i](GenerateRandomValues(j)));
                    }
                }

                SortingResult summedResult = new SortingResult();
                summedResult.averageTimeTaken  = allResultsSingleSort.Sum(x => x.averageTimeTaken) / allResultsSingleSort.Count();
                summedResult.isCorrectlySorted = allResultsSingleSort.TrueForAll(x => x.isCorrectlySorted);
                summedResult.sortingName       = allResultsSingleSort[0].sortingName;
                sortingResults.Add(summedResult);
            }
        }

        for (int i = 0; i < sortingResults.Count; i++)
        {
            GUI.Label(new Rect(10, height += 20, 300, 20), string.Format("--- {0} ---", sortingResults[i].sortingName));
            GUI.Label(new Rect(10, height += 20, 300, 20), "Sort Time: " + sortingResults[i].averageTimeTaken);
            GUI.Label(new Rect(10, height += 20, 300, 20), "Is sorted correctly: " + sortingResults[i].isCorrectlySorted);
        }
    }