View difference between Paste ID: 2QVsRuyP and mwqnm2re

 using System;
-using System.Collections.Generic;
+using System.Diagnostics;
-using System.Linq;
+
-using System.Text;
+namespace ArrayTest {
 
-namespace ArrTest2 {
+
         const int SizeX = 512;
         const int SizeY = 512;
         const int SizeZ = 128;
-            const int sizeX = 512;
+        const int Repets = 20;
-            const int sizeY = 512;
+
-            const int sizeZ = 128;
+
 
             //массивы массивов
-            var allocateRagged = Calc("Test allocate ragged array", _ => {
+            var allocateJagged = TimeTest.Calc("Test allocate jagged array", _ => {
-                var arrX = new int[sizeX][][];
+                var arrX = new int[SizeX][][];
-                for (var x = 0; x < sizeX; x++) {
+                for (var x = 0; x < SizeX; x++) {
-                    var arrY = new int[sizeY][];
+                    var arrY = new int[SizeY][];
-                    for (var y = 0; y < sizeY; y++)
+                    for (var y = 0; y < SizeY; y++)
-                        arrY[y] = new int[sizeZ];
+                        arrY[y] = new int[SizeZ];
                     arrX[x] = arrY;
                 }
                 return arrX;
             });
-            var raggedArr = allocateRagged.Data;
+            var jaggedArr = allocateJagged.Data;
-            var xyzRagged = Exec(20, "Test fill ragged array in xyz order", _ => {
+            var xyzRagged = TimeTest.Exec(Repets, "Test fill jagged array in xyz order", _ => {
                 var i = 0;
-                for (var x = 0; x < sizeX; x++)
+                for (var x = 0; x < SizeX; x++)
-                    for (var y = 0; y < sizeY; y++)
+                    for (var y = 0; y < SizeY; y++)
-                        for (var z = 0; z < sizeZ; z++)
+                        for (var z = 0; z < SizeZ; z++)
-                            raggedArr[x][y][z] = i++;
+                            jaggedArr[x][y][z] = i++;
             });
 
             //многомерные массивы
             var allocateMultdim = TimeTest.Calc("Test allocate multidimension array", _ => {
-            var allocateMultdim = Calc("Test allocate multidimension array", _ => {
+                return new int[SizeX, SizeY, SizeZ];
-                return new int[sizeX, sizeY, sizeZ];
+
             var multdimArr = allocateMultdim.Data;
             var xyzMultdim = TimeTest.Exec(Repets, "Test fill multidimension in xyz order", _ => {
-            var xyzMultdim = Exec(20, "Test fill multidimension in xyz order", _ => {
+
                 for (var x = 0; x < SizeX; x++)
-                for (var x = 0; x < sizeX; x++)
+                    for (var y = 0; y < SizeY; y++)
-                    for (var y = 0; y < sizeY; y++)
+                        for (var z = 0; z < SizeZ; z++)
-                        for (var z = 0; z < sizeZ; z++)
+
             });
             var xyzMultdimUnfase = TimeTest.Exec(Repets, "Test unsafe fill multidimension in xyz order", _ => {
                 unsafe {
                     var i = 0;
-            //плоское массив
+                    fixed (int* prt = multdimArr) {
-            var allocateFlat = Calc("Test allocate flat array", _ => {
+                        for (var x = 0; x < SizeX; x++)
-                return new Flat3dArray(sizeX, sizeY, sizeZ);
+                            for (var y = 0; y < SizeY; y++)
                                 for (var z = 0; z < SizeZ; z++)
                                     prt[(x * SizeY + y) * SizeZ + z] = i++;
-            var xyzFlat = Exec(20, "Test fill flat array in xyz order", _ => {
+                    }
                 }
-                for (var x = 0; x < sizeX; x++)
+
-                    for (var y = 0; y < sizeY; y++)
+
-                        for (var z = 0; z < sizeZ; z++)
+            //плоские массивы
             var allocateFlat = TimeTest.Calc("Test allocate flat array", _ => {
                 return new Flat3DArray(SizeX, SizeY, SizeZ);
-            var xzyFlat = Exec(20, "Test fill flat array in xzy order", _ => {
+
             var flatArr = allocateFlat.Data;
-                for (var x = 0; x < sizeX; x++)
+            var xyzFlat = TimeTest.Exec(Repets, "Test fill flat array in xyz order", _ => {
-                    for (var z = 0; z < sizeZ; z++)
+
-                        for (var y = 0; y < sizeY; y++)
+                for (var x = 0; x < SizeX; x++)
                     for (var y = 0; y < SizeY; y++)
                         for (var z = 0; z < SizeZ; z++)
                             flatArr.Set(x, y, z, i++);
-            Console.WriteLine(allocateRagged);
+
             var xyzFlatUnsafe = TimeTest.Exec(Repets, "Test unssafe fill flat array in xyz order", _ => {
                 unsafe {
                     var i = 0;
                     fixed (int* prt = flatArr.FlatArray) {
                         for (var x = 0; x < SizeX; x++)
-            Console.WriteLine(xzyFlat);
+                            for (var y = 0; y < SizeY; y++)
                                 for (var z = 0; z < SizeZ; z++)
                                     prt[(x * SizeY + y) * SizeZ + z] = i++;
                     }
                 }
-        public static TimeTestData<T> Calc<T>(string testName, Func<bool, T> func) {
+
 
-            var s = DateTime.Now;
+            Console.WriteLine(allocateJagged);
             Console.WriteLine(xyzRagged);
-            var e = DateTime.Now;
+
             Console.WriteLine(xyzMultdim);
-            return new TimeTestData<T>(v, s, e, testName);
+            Console.WriteLine(xyzMultdimUnfase);
             Console.WriteLine(allocateFlat);
             Console.WriteLine(xyzFlat);
-        public static TimeTest Exec(int repeats, string testName, Action<bool> act) {
+            Console.WriteLine(xyzFlatUnsafe);
 
-            var s = DateTime.Now;
+
         }
 
-            var e = DateTime.Now;
+
 
-            return new TimeTest(s, e, testName, repeats);
+
     public class Flat3DArray {
         public readonly int[] FlatArray;
         public readonly int SizeX;
         public readonly int SizeY;
         public readonly int SizeZ;
-    public class Flat3dArray {
+        public Flat3DArray(int sizeX, int sizeY, int sizeZ) {
-        private int[] _arr;
+            FlatArray = new int[sizeX * sizeY * sizeZ];
             SizeX = sizeX;
             SizeY = sizeY;
             SizeZ = sizeZ;
-        public Flat3dArray(int sizeX, int sizeY, int sizeZ) {
+
-            _arr = new int[sizeX * sizeY * sizeZ];
+
             return FlatArray[(x * SizeY + y) * SizeZ + z];
         }
         public void Set(int x, int y, int z, int value) {
             FlatArray[(x * SizeY + y) * SizeZ + z] = value;
-        private int toFlat(int x, int y, int z) {
+
-            return x * SizeY * SizeZ + y * SizeZ + z;
+
 
 
-            return _arr[toFlat(x, y, z)];
+
 
         public class Info {
-            _arr[toFlat(x, y, z)] = value;
+            public readonly string Name;
             public readonly long ElapsedMilliseconds;
             public readonly int Repeats;
             public Info(long elapsedMilliseconds, string name, int repeats = 1) {
                 Repeats = repeats;
-        public readonly string Name;
+                ElapsedMilliseconds = elapsedMilliseconds;
-        public readonly long Ticks;
+                Name = name;
-        public readonly int Repeats;
+            }
-        public TimeTest(DateTime start, DateTime end, string name, int repeats = 1) {
+            public override string ToString() {
-            Ticks = end.Ticks - start.Ticks;
+                return Repeats == 1
-            Repeats = repeats;
+                    ? string.Format("{1}: {0}ms", ElapsedMilliseconds, Name)
-            Name = name;
+                    : string.Format("{2}: {0}ms ({3} repeats, avr {1}ms)",
                                     ElapsedMilliseconds, ElapsedMilliseconds / Repeats, Name, Repeats);
             }
-        public override string ToString() {
+
-            var total = Ticks / 1000.0 / 10000.0;
+
-            return Repeats == 1
+        public class InfoData<T> : Info {
-                ? string.Format("{1}: {0} seconds", total, Name)
+            public readonly T Data;
-                : string.Format("{2}: {0} seconds (repeated {3} avr {1} seconds)",
+            public InfoData(T data, long elapsedMilliseconds, string name)
-                                total, total / Repeats, Name, Repeats);
+                : base(elapsedMilliseconds, name) {
                 Data = data;
             }
         }
 
-    public class TimeTestData<T> : TimeTest {
+        public static InfoData<T> Calc<T>(string testName, Func<bool, T> func) {
-        public readonly T Data;
+
-        public TimeTestData(T data, DateTime start, DateTime end, string name)
+
-            : base(start, end, name) {
+            var timer = Stopwatch.StartNew();
-            Data = data;
+
             timer.Stop();
             Console.WriteLine("{1}| Completed: {0}", testName, DateTime.Now);
             return new InfoData<T>(v, timer.ElapsedMilliseconds, testName);
         }
 
         public static Info Exec(int repeats, string testName, Action<bool> act) {
             Console.WriteLine("{1}| Starting: {0}", testName, DateTime.Now);
             var timer = Stopwatch.StartNew();
             for (var i = 0; i < repeats; i++)
                 act(true);
             timer.Stop();
             Console.WriteLine("{1}| Completed: {0}", testName, DateTime.Now);
             return new Info(timer.ElapsedMilliseconds, testName, repeats);
         }
 
     }
 
 }