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);
}
// 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
}
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);
}
}
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);
}
}