static void Main() { // Determine how many cores/processors there are on this machine. // int coreCount = Environment.ProcessorCount; Console.WriteLine("*********************************"); Console.WriteLine("Process/core count = {0}", coreCount); // Get some data to work with. // double[] data = GetData(); Stopwatch sw = Stopwatch.StartNew(); // Process the entire data set using one thread // for comparison purposes. // ArrayProcessor wholeArray = new ArrayProcessor(data, 0, data.Length - 1); wholeArray.ComputeSum(); sw.Stop(); Console.WriteLine( "1 thread computed {0:n0} in {1:n0} ms", wholeArray.Sum, sw.ElapsedMilliseconds ); Console.ReadKey(); }
public void Test1() { ArrayProcessor arrayProcessor = new ArrayProcessor(); int[] testArray = { -10000, 10, 0, 1000, 1000, 5544, -5000, 3322, 7777, 2222, 9999, 120000 }; // делаем копию массива что передаем, чтобы убедится что после работы программы исходный - не затрагивали int[] testArrayCopy = new int[testArray.Length]; Array.Copy(testArray, testArrayCopy, testArray.Length); int[] result = arrayProcessor.SortAndFilter(testArray); Assert.Multiple(() => { Assert.AreEqual(testArray, testArrayCopy); Assert.That(result, Is.Ordered); Assert.That(result, Has.All.InRange(1000, 9999)); }); testArray = new int[0]; result = arrayProcessor.SortAndFilter(testArray); Assert.AreEqual(testArray, result); testArray = new int[] { 1000, 1000, 1000 }; result = arrayProcessor.SortAndFilter(testArray); Assert.AreEqual(testArray, result); testArray = null; Assert.Throws <ArgumentNullException>(() => arrayProcessor.SortAndFilter(testArray)); Assert.Pass(); }
static void Main(string[] args) { ConsoleHelper.WriteText($"Greetings!\nThis programm generates the random two-dimensional array and finds summ of even values.\n"); int[,] array = ArrayGenerator.GenerateTwoDimensional(); ArrayProcessor.CalculateSummOfEven(array); ConsoleHelper.PressAnyKey(); }
static void Main(string[] args) { ConsoleHelper.WriteText($"Greetings!\nThis programm generates the random one-dimensional array and calculates sum of its non-negative values.\n"); int[] array = ArrayGenerator.GenerateOneDimensional(); ArrayProcessor.CalculateNonNegativeSumm(array); ConsoleHelper.PressAnyKey(); }
static void Main(string[] args) { ConsoleHelper.WriteText($"Greetings!\nThis programm generates and sorts the random one-dimensional array and finds it min/max values.\n"); int [] array = ArrayGenerator.GenerateOneDimensional(); ArrayProcessor.FindMax(array); ArrayProcessor.FindMin(array); ArrayProcessor.BubbleSort(array); ConsoleHelper.PressAnyKey(); }
static void Main(string[] args) { ConsoleHelper.WriteText($"Greetings!\nThis programm generates and sorts the random three-dimensional array and replaces all positive values with 0\n"); int[, ,] array = ArrayGenerator.GenerateThreeDimensional(); ConsoleHelper.WriteText($"Press any key to replace..."); ConsoleHelper.PressAnyKey(); ArrayProcessor.ReplaceAllPositive(array); ConsoleHelper.PressAnyKey(); }
public void Delete_repeating_elements() { int[] X = { -5, -5, -5, -5, -5 }; int[] Y = new int[X.Length]; ArrayProcessor array = new ArrayProcessor(); Y = array.SortAndFilter(X); Assert.AreEqual(-5, Y[0]); }
public void NoNegatives() { ArrayProcessor processor = new ArrayProcessor(); double[] array = new double[] { 7, 5, 123, -50 }; double[] newArray = processor.SortAndFilter(array); Assert.Throws <InvalidOperationException>(() => newArray.First(item => item < 0)); }
public void AllConditionsTest() { double[] a = { 1, -1, 2, 3, 2, 73, 6, 2 }; double[] expected = { 73, 6, 3, 2, 1 }; ArrayProcessor arr = new ArrayProcessor(); double[] actual = arr.SortAndFilter(a); CollectionAssert.AreEqual(expected, actual); }
public void SortTest() { double[] a = { 0, 3, 7, 1 }; double[] expected = { 7, 3, 1, 0 }; ArrayProcessor arr = new ArrayProcessor(); double[] actual = arr.SortAndFilter(a); CollectionAssert.AreEqual(expected, actual); }
public void IsOrdered() { ArrayProcessor processor = new ArrayProcessor(); double[] array = new double[] { 7, 5, 123, -50 }; double[] newArray = processor.SortAndFilter(array); CollectionAssert.IsOrdered(newArray); }
public void ReplacingNegativeNumbersTest() { double[] a = { -76, -3, -1 }; double[] expected = { 76, 3, 1 }; ArrayProcessor arr = new ArrayProcessor(); double[] actual = arr.SortAndFilter(a); CollectionAssert.AreEqual(expected, actual); }
public void Sort_elements() { int[] X = { -5, -2, -8, 10, 11, 45 }; int[] Y = new int[X.Length]; ArrayProcessor array = new ArrayProcessor(); Y = array.SortAndFilter(X); Array.Sort(X); CollectionAssert.AreEqual(X, Y); }
public void NoDuplicates() { ArrayProcessor processor = new ArrayProcessor(); double[] array = new double[] { 7, 5, 123, -50 }; double[] newArray = processor.SortAndFilter(array); CollectionAssert.AllItemsAreUnique(newArray); }
public void SortAndFilter_originArr_ArrFilteredAndSorted_() { int[] ororiginArr = new int[] { 0, -2, -5, -7, 9, -7, 12, -5, 4, 44, -2, 8 }; int[] expectedArr = new int[] { -7, -5, -2, 0, 4, 8, 9, 12, 44 }; ArrayProcessor arrProc = new ArrayProcessor(); int[] resultArr = arrProc.SortAndFilter(ororiginArr); CollectionAssert.AreEqual(resultArr, expectedArr); }
public void SortAndFilter_originArr_originArrNotChange_() { int[] ororiginArr = new int[] { 0, -2, -5, -7, 9, -7, 12, -5, 4, 44, -2, 8 }; int[] actualArr = new int[] { 0, -2, -5, -7, 9, -7, 12, -5, 4, 44, -2, 8 }; ArrayProcessor arrProc = new ArrayProcessor(); int[] resultArr = arrProc.SortAndFilter(ororiginArr); CollectionAssert.AreEqual(ororiginArr, actualArr); }
public void THeOriginalOneShouldRemainTheSame() { ArrayProcessor processor = new ArrayProcessor(); double[] array = new double[] { 7, 5, 123, -50 }; double[] copy = new double[] { 7, 5, 123, -50 }; double[] newArray = processor.SortAndFilter(array); CollectionAssert.AreEqual(array, copy); }
public void CanSortAndFilterArrayAssertCollection() { //Arrange ArrayProcessor ap = new ArrayProcessor(); int[] tmp = { -3, -10, 9, 9, 8, -3, -10, 4, 5, 1 }; int[] fin = { -10, -3, 1, 4, 5, 8, 9, 9 }; //Act tmp = ap.SortAndFilter(tmp); //Assert NUnit.Framework.CollectionAssert.AreEqual(fin, tmp); }
public void CanSortAndFilterArrayMSUnit() { //Arrange ArrayProcessor ap2 = new ArrayProcessor(); int[] tmp = { -10, 9, 9, 8, -3, -10, 4, 5, 1 }; int[] fin = { -10, -3, 1, 4, 5, 8, 9, 9 }; //Act tmp = ap2.SortAndFilter(tmp); //Assert //Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(fin, tmp); }
public void Test_elements_Array() { ArrayProcessor array = new ArrayProcessor(); int[] X = { -5, -2, -2, -2, -8, -5, 10, 11, 11, 45 }; int[] B = { -5, -2, -8, 10, 11, 45 }; int a = array.SortAndFilter(X).Length; int[] Y = new int[a]; Y = array.SortAndFilter(X); Array.Sort(B); CollectionAssert.AreEquivalent(B, Y); }
public void testArrayProccessor() { //arange int[] actual = { -8, 5443, -20, 4559, 0, -20, 2, -1323, 10000, -1323 }; int[] excepting = { -1323, -20, -8, 0, 2, 4559, 5443, 10000 }; //act ArrayProcessor arrProc = new ArrayProcessor(); int[] result = arrProc.SortAndFilter(actual); //assert CollectionAssert.AreEqual(excepting, result); }
public void testSameArray() { int[] actual = { -8, 5443, -20, 4559, 0, -20, 2, -1323, 10000, -1323 }; int[] excepting = { -8, 5443, -20, 4559, 0, -20, 2, -1323, 10000, -1323 }; //act ArrayProcessor arrProc = new ArrayProcessor(); int[] result = arrProc.SortAndFilter(actual); //assert //Проверяем, то оригинальный массив не меняется CollectionAssert.AreEqual(excepting, actual); }
public static void Main(string[] args) { var coresCount = Environment.ProcessorCount; var threads = new List<Thread>(coresCount); var arrayProcessors = new List<ArrayProcessor>(coresCount); // Build array var arraySize = 50000000; var array = GetArray(arraySize); var stopwatch = Stopwatch.StartNew(); // Run N Threads to deal with N SMALLER problems var elementsPerCore = arraySize / coresCount; var elementsLeftOver = arraySize % coresCount; for (int i = 0; i < coresCount; i++) { var startIndex = i * elementsPerCore; var elementsToProcessCount = elementsPerCore; if (i == coresCount - 1) { elementsToProcessCount += elementsLeftOver; } var arrayProcessor = new ArrayProcessor(array, startIndex, elementsToProcessCount); arrayProcessors.Add(arrayProcessor); var thread = new Thread(arrayProcessor.CalculateSum); threads.Add(thread); thread.Start(); } // Wait for the tasks to finish and calculate the final sum BigInteger totalSum = 0; for (int i = 0; i < threads.Count; i++) { threads[i].Join(); totalSum += arrayProcessors[i].CalculatedSum; } stopwatch.Stop(); // Elapsed time: 1900-3300 ms // Sum: 1249999975000000 Console.WriteLine($"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds}"); Console.WriteLine($"Sum: {totalSum}"); }
static void Main(string[] args) { // Build array var arraySize = 50000000; // 50 000 000 var array = GetArray(arraySize); // Run ONE THREAD to deal with ONE LARGE PROBLEM var stopwatch = Stopwatch.StartNew(); var startIndex = 0; var elementsToProcessCount = arraySize; var arrayProcessor = new ArrayProcessor(array, startIndex, elementsToProcessCount); arrayProcessor.CalculateSum(); var totalSum = arrayProcessor.CalculatedSum; stopwatch.Stop(); // Еlapsed time: 6700-7100 ms // Sum: 1249999975000000 Console.WriteLine($"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds} ms"); Console.WriteLine($"Sum: {totalSum}"); }
public void Setup() { array = new ArrayProcessor(); }
public void Setup() { _processor = new ArrayProcessor(); }
static void Main() { // Determine how many cores/processors there are on this machine. // int coreCount = Environment.ProcessorCount; Console.WriteLine("Process/core count = {0}", coreCount); // Get some data to work with. // double[] data = GetData(); Stopwatch sw = Stopwatch.StartNew(); // Setup same-sized arrays of references to ArraySlice // Thread objects; one per core/processor. // ArrayProcessor[] slices = new ArrayProcessor[coreCount]; Thread[] threads = new Thread[coreCount]; // Divide the work (roughly) evenly among the // number of threads we're about to start. The last // thread will pickup any leftovers if the data size // is not evenly divisible by the core count. // int indexesPerThread = data.Length / coreCount; int leftOverIndexes = data.Length % coreCount; for (int n = 0; n < coreCount; n++) { int firstIndex = (n * indexesPerThread); int lastIndex = firstIndex + indexesPerThread - 1; if (n == (coreCount - 1)) { lastIndex += leftOverIndexes; } // Setup the array slice that describes this // portion of the array. // ArrayProcessor slice = new ArrayProcessor(data, firstIndex, lastIndex); slices[n] = slice; // Start the thread that will process this slice. // threads[n] = new Thread(slice.ComputeSum); threads[n].Start(); } // Once all the threads have been started, wait for // them to complete their assigned computations, then // add their sum to the running total. // double sum = 0; for (int n = 0; n < coreCount; n++) { threads[n].Join(); sum += slices[n].Sum; } sw.Stop(); // Display the results. // Console.WriteLine( "{0} threads computed {1:n0} in {2:n0} ms", coreCount, sum, sw.ElapsedMilliseconds ); Console.ReadKey(); }
public void ThrowsWIthNull() { ArrayProcessor processor = new ArrayProcessor(); Assert.Throws <ArgumentNullException>(() => processor.SortAndFilter(null)); }
public void UniqueValue(double[] expectedResult, double[] obtainedResult) { ArrayProcessor arrayProcessor = new ArrayProcessor(); CollectionAssert.AreEqual(expectedResult, arrayProcessor.UniqueArray(obtainedResult)); }
public void TestPosition(int[] expectedResult, int[] obtainedResult) { ArrayProcessor arrayProcessor = new ArrayProcessor(); CollectionAssert.AreEqual(expectedResult, arrayProcessor.SortAndFilter(obtainedResult)); }
public void Removing_excess(int[] expectedResult, int[] obtainedResult) { ArrayProcessor arrayProcessor = new ArrayProcessor(); CollectionAssert.AreEqual(expectedResult, arrayProcessor.CreateNewArray(obtainedResult)); }
public void SortTest(int[] expectedResult, int[] obtainedResult) { ArrayProcessor arrayProcessor = new ArrayProcessor(); CollectionAssert.AreEqual(expectedResult, arrayProcessor.SortArray(obtainedResult)); }