public void GetRandomArray_SecondMethod_NormalCount(int count)
        {
            var result = RandomArrayGenerator.GetRandomArray2(count);
            var sum    = result.Sum();

            Assert.IsFalse(sum > 1 || sum < 1);
        }
Пример #2
0
        static void Main(string[] args)
        {
            ArrayGenerator hat    = new RandomArrayGenerator(10000, 20);
            ArrayGenerator topHat = new NearlySortedArray(10, 20);

            var nearlySortet = topHat.NewArray();
            var unsorted     = hat.NewArray();

            ISuperSorter bubble = new BubbleSort();

            var sorted = bubble.Sort(nearlySortet);

            foreach (var item in nearlySortet)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine("");
            foreach (var item in sorted)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine("");
            Console.WriteLine("The sorting took: " + bubble.ElapsedTime + " MiliSeconds!");
            Console.ReadKey();
        }
Пример #3
0
        public void TestCountElementsInArray()
        {
            const int            arraySize            = 100;
            RandomArrayGenerator randomArrayGenerator = new RandomArrayGenerator();

            int[] resultArray = randomArrayGenerator.Generate(arraySize);
            Assert.AreEqual(resultArray.Length, arraySize);
        }
        public void GetRandomArray_SecondMethod_CheckAllElements(int count)
        {
            var result = RandomArrayGenerator.GetRandomArray2(count);

            foreach (var number in result)
            {
                Assert.IsTrue(number > 0 || number < 1);
            }
        }
Пример #5
0
        public void TestCheckElementsBounds()
        {
            RandomArrayGenerator randomArrayGenerator = new RandomArrayGenerator();

            int[] resultArray = randomArrayGenerator.Generate(100000);
            foreach (var element in resultArray)
            {
                Assert.IsTrue((element >= randomArrayGenerator.StartValue) && (element < randomArrayGenerator.EndValue));
            }
        }
Пример #6
0
        private static void DoubleSorting()
        {
            var arrayToSort = RandomArrayGenerator.GenerateDoubleArray(-30, 23242342);

            Logger.Log("Double array sorting");

            TimeTracker.MeasureTime("Insertion sort", () =>
            {
                SortingAlgorithms.InsertionSort(arrayToSort);
            });

            TimeTracker.MeasureTime("Selection sort", () =>
            {
                SortingAlgorithms.SelectionSort(arrayToSort);
            });

            TimeTracker.MeasureTime("Quick sort", () =>
            {
                SortingAlgorithms.QuickSort(arrayToSort, 0, arrayToSort.Length - 1);
            });
        }
Пример #7
0
        public void TestUniformDistribution()
        {
            RandomArrayGenerator randomArrayGenerator = new RandomArrayGenerator();

            randomArrayGenerator.StartValue = -100;
            randomArrayGenerator.EndValue   = 100;
            int generateCount = randomArrayGenerator.EndValue - randomArrayGenerator.StartValue;

            int[] resultArray = randomArrayGenerator.Generate(generateCount * 100000);

            int[] counts = new int[generateCount];
            foreach (var element in resultArray)
            {
                counts[element - randomArrayGenerator.StartValue]++;
            }

            double averageCount = (double)resultArray.Length / generateCount;

            foreach (var count in counts)
            {
                double despersion = Math.Sqrt(Math.Pow(count - averageCount, 2) / resultArray.Length);
                Assert.IsTrue(despersion < 0.3);
            }
        }
Пример #8
0
 static GetRandomArray()
 {
     Rand = RandomArrayGenerator.GetInstance();
 }
 public void GetRandomArray_SecondMethod_InvalidCount_ArgumentException(int count)
 {
     Assert.Catch <ArgumentException>(() => RandomArrayGenerator.GetRandomArray2(count));
 }