/LinqLibTests/Array/ArrayExtensionsTests.cs

# · C# · 1040 lines · 835 code · 205 blank · 0 comment · 91 complexity · d72831d539bb9f3778f57515d1e41719 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. using System.Collections.Generic;

    2. 

  2. using System.Linq;

    3. 

  3. using LinqLib.Array;

    4. 

  4. using LinqLib.Sequence;

    5. 

  5. using Microsoft.VisualStudio.TestTools.UnitTesting;

    6. 

  6. 

    7. 

  7. namespace LinqLibTests.Array

    8. 

  8. {

    9. 

  9.   [TestClass()]

    10. 

  10.   public class ArrayExtensionssTests

    11. 

  11.   {

    12. 

  12.     #region Slice and Fuse

    13. 

  13. 

    14. 

  14.     [TestMethod()]

    15. 

  15.     public void Slice2D()

    16. 

  16.     {

    17. 

  17.       const int Y = 10;

    18. 

  18.       const int X = 8;

    19. 

  19.       int i = 0;

    20. 

  20. 

    21. 

  21.       int[,] arr1 = new int[Y, X];

    22. 

  22.       List<int[]> expected = new List<int[]>();

    23. 

  23. 

    24. 

  24.       for (int y = 0; y < Y; y++)

    25. 

  25.       {

    26. 

  26.         expected.Add(new int[X]);

    27. 

  27.         for (int x = 0; x < X; x++)

    28. 

  28.         {

    29. 

  29.           arr1[y, x] = i;

    30. 

  30.           expected[y][x] = i;

    31. 

  31.           i++;

    32. 

  32.         }

    33. 

  33.       }

    34. 

  34. 

    35. 

  35.       List<int[]> actual = arr1.Slice().ToList();

    36. 

  36. 

    37. 

  37.       for (int y = 0; y < Y; y++)

    38. 

  38.         for (int x = 0; x < X; x++)

    39. 

  39.           Assert.IsTrue(expected[y][x] == actual[y][x]);

    40. 

  40. 

    41. 

  41.       var actual2 = actual.Fuse();

    42. 

  42.       Assert.IsTrue(arr1.ArrayEquals(actual2));

    43. 

  43.     }

    44. 

  44. 

    45. 

  45.     [TestMethod()]

    46. 

  46.     public void Slice3D()

    47. 

  47.     {

    48. 

  48.       const int Z = 5;

    49. 

  49.       const int Y = 10;

    50. 

  50.       const int X = 8;

    51. 

  51.       int i = 0;

    52. 

  52. 

    53. 

  53.       int[, ,] arr1 = new int[Z, Y, X];

    54. 

  54.       List<int[,]> expected = new List<int[,]>();

    55. 

  55. 

    56. 

  56.       for (int z = 0; z < Z; z++)

    57. 

  57.       {

    58. 

  58.         expected.Add(new int[Y, X]);

    59. 

  59.         for (int y = 0; y < Y; y++)

    60. 

  60.           for (int x = 0; x < X; x++)

    61. 

  61.           {

    62. 

  62.             arr1[z, y, x] = i;

    63. 

  63.             expected[z][y, x] = i;

    64. 

  64.             i++;

    65. 

  65.           }

    66. 

  66.       }

    67. 

  67. 

    68. 

  68.       List<int[,]> actual = arr1.Slice().ToList();

    69. 

  69. 

    70. 

  70.       for (int z = 0; z < Z; z++)

    71. 

  71.         for (int y = 0; y < Y; y++)

    72. 

  72.           for (int x = 0; x < X; x++)

    73. 

  73.             Assert.IsTrue(expected[z][y, x] == actual[z][y, x]);

    74. 

  74. 

    75. 

  75.       var actual2 = actual.Fuse();

    76. 

  76.       Assert.IsTrue(arr1.ArrayEquals(actual2));

    77. 

  77.     }

    78. 

  78. 

    79. 

  79.     [TestMethod()]

    80. 

  80.     public void Slice4D()

    81. 

  81.     {

    82. 

  82.       const int A = 7;

    83. 

  83.       const int Z = 5;

    84. 

  84.       const int Y = 10;

    85. 

  85.       const int X = 8;

    86. 

  86.       int i = 0;

    87. 

  87. 

    88. 

  88.       int[, , ,] arr1 = new int[A, Z, Y, X];

    89. 

  89.       List<int[, ,]> expected = new List<int[, ,]>();

    90. 

  90. 

    91. 

  91.       for (int a = 0; a < A; a++)

    92. 

  92.       {

    93. 

  93.         expected.Add(new int[Z, Y, X]);

    94. 

  94.         for (int z = 0; z < Z; z++)

    95. 

  95.           for (int y = 0; y < Y; y++)

    96. 

  96.             for (int x = 0; x < X; x++)

    97. 

  97.             {

    98. 

  98.               arr1[a, z, y, x] = i;

    99. 

  99.               expected[a][z, y, x] = i;

    100. 

  100.               i++;

    101. 

  101.             }

    102. 

  102.       }

    103. 

  103. 

    104. 

  104.       List<int[, ,]> actual = arr1.Slice().ToList();

    105. 

  105. 

    106. 

  106.       for (int a = 0; a < A; a++)

    107. 

  107.         for (int z = 0; z < Z; z++)

    108. 

  108.           for (int y = 0; y < Y; y++)

    109. 

  109.             for (int x = 0; x < X; x++)

    110. 

  110.               Assert.IsTrue(expected[a][z, y, x] == actual[a][z, y, x]);

    111. 

  111. 

    112. 

  112.       var actual2 = actual.Fuse();

    113. 

  113.       Assert.IsTrue(arr1.ArrayEquals(actual2));

    114. 

  114.     }

    115. 

  115. 

    116. 

  116.     #endregion

    117. 

  117. 

    118. 

  118.     #region Split (up to 4D - any type)

    119. 

  119. 

    120. 

  120.     [TestMethod()]

    121. 

  121.     public void Split1D()

    122. 

  122.     {

    123. 

  123.       double[] src = new double[] { 1, 2, 3, 4, 5, 6, 7, 8 };

    124. 

  124.       var actual1 = src.CircularShift(4).ToArray().Fuse();

    125. 

  125.       var actual2 = src.CircularShift(3, 2).ToArray().Fuse();

    126. 

  126.       var expected1 = ArrayReader.GetDoubleArray("Split1D-1");

    127. 

  127.       var expected2 = ArrayReader.GetDoubleArray("Split1D-2");

    128. 

  128. 

    129. 

  129.       Assert.IsTrue(src.Split(3).ToArray().Fuse().ArrayEquals(src.CircularShift(3, 3).ToArray().Fuse()));

    130. 

  130.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    131. 

  131.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    132. 

  132.     }

    133. 

  133. 

    134. 

  134.     [TestMethod()]

    135. 

  135.     public void Split2D()

    136. 

  136.     {

    137. 

  137.       double[,] src = Enumerator.Generate<double>(1, 1, 12).ToArray(3, 4);

    138. 

  138. 

    139. 

  139.       var actual1 = src.CircularShift(2, 2).ToArray().Fuse();

    140. 

  140.       var actual2 = src.CircularShift(1, 2, 2, 2).ToArray().Fuse();

    141. 

  141.       var expected1 = ArrayReader.GetDoubleArray("Split2D-1");

    142. 

  142.       var expected2 = ArrayReader.GetDoubleArray("Split2D-2");

    143. 

  143. 

    144. 

  144.       Assert.IsTrue(src.Split(2, 2).ToArray().Fuse().ArrayEquals(src.CircularShift(2, 2, 2, 2).ToArray().Fuse()));

    145. 

  145.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    146. 

  146.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    147. 

  147.     }

    148. 

  148. 

    149. 

  149.     [TestMethod()]

    150. 

  150.     public void Split3D()

    151. 

  151.     {

    152. 

  152.       double[, ,] src = Enumerator.Generate<double>(1, 1, 36).ToArray(3, 3, 4);

    153. 

  153. 

    154. 

  154.       var actual1 = src.CircularShift(2, 2, 2).ToArray().Fuse();

    155. 

  155.       var actual2 = src.CircularShift(1, 2, 2, 1, 2, 2).ToArray().Fuse();

    156. 

  156.       var expected1 = ArrayReader.GetDoubleArray("Split3D-1");

    157. 

  157.       var expected2 = ArrayReader.GetDoubleArray("Split3D-2");

    158. 

  158. 

    159. 

  159.       Assert.IsTrue(src.Split(2, 2, 2).ToArray().Fuse().ArrayEquals(src.CircularShift(2, 2, 2, 2, 2, 2).ToArray().Fuse()));

    160. 

  160.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    161. 

  161.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    162. 

  162.     }

    163. 

  163. 

    164. 

  164.     [TestMethod()]

    165. 

  165.     public void Split4D()

    166. 

  166.     {

    167. 

  167.       double[, , ,] src = Enumerator.Generate<double>(1, 1, 256).ToArray(3, 3, 3, 3);

    168. 

  168. 

    169. 

  169.       var actual1 = src.CircularShift(2, 2, 3, 2).ToArray();

    170. 

  170.       var actual2 = src.CircularShift(1, 2, 2, 1, 2, 1, 1, 2).ToArray();

    171. 

  171. 

    172. 

  172.       var actual3 = src.Split(2, 2, 2, 2).ToArray();

    173. 

  173.       var actual4 = src.CircularShift(2, 2, 2, 2, 2, 2, 2, 2).ToArray();

    174. 

  174. 

    175. 

  175.       for (int i = 0; i < actual1.Length; i++)

    176. 

  176.         Assert.IsTrue(actual1[i].ArrayEquals(ArrayReader.GetDoubleArray(string.Format("Split4D-1.{0}", i))));

    177. 

  177.       for (int i = 0; i < actual2.Length; i++)

    178. 

  178.         Assert.IsTrue(actual2[i].ArrayEquals(ArrayReader.GetDoubleArray(string.Format("Split4D-2.{0}", i))));

    179. 

  179. 

    180. 

  180.       Assert.IsTrue(actual3.Length == actual4.Length);

    181. 

  181.       for (int i = 0; i < actual3.Length; i++)

    182. 

  182.         Assert.IsTrue(actual3[i].ArrayEquals(actual4[i]));

    183. 

  183.     }

    184. 

  184. 

    185. 

  185.     #endregion

    186. 

  186. 

    187. 

  187.     #region ToArray and AsEnumerable

    188. 

  188. 

    189. 

  189.     [TestMethod()]

    190. 

  190.     public void ToArrayTest()

    191. 

  191.     {

    192. 

  192.       int[] expected1 = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0 };

    193. 

  193.       int[] actual1 = Enumerable.Range(0, 16).ToArray(20);

    194. 

  194.       Assert.IsTrue(expected1.ArrayEquals(actual1));

    195. 

  195. 

    196. 

  196.       int[,] expected2 = new int[,] { { 0, 1, 2, 3, 4, 5, 6, 7 }, { 8, 9, 10, 11, 12, 13, 0, 0 } };

    197. 

  197.       int[,] actual2 = Enumerable.Range(0, 14).ToArray(2, 8);

    198. 

  198.       Assert.IsTrue(expected2.ArrayEquals(actual2));

    199. 

  199. 

    200. 

  200.       int[, ,] expected3 = new int[,,] { { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 } }, { { 9, 10, 11 }, { 12, 13, 14 }, { 15, 16, 17 } }, { { 18, 19, 20 }, { 21, 22, 23 }, { 24, 25, 0 } } };

    201. 

  201.       int[, ,] actual3 = Enumerable.Range(0, 26).ToArray(3, 3, 3);

    202. 

  202.       Assert.IsTrue(expected3.ArrayEquals(actual3));

    203. 

  203. 

    204. 

  204.       int[, , ,] expected4 = new int[,,,] { { { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 } }, { { 9, 10, 11 }, { 12, 13, 14 }, { 15, 16, 17 } } }, { { { 18, 19, 20 }, { 21, 22, 23 }, { 24, 25, 26 } }, { { 27, 28, 29 }, { 30, 31, 32 }, { 0, 0, 0 } } } };

    205. 

  205.       int[, , ,] actual4 = Enumerable.Range(0, 33).ToArray(2, 2, 3, 3);

    206. 

  206.       Assert.IsTrue(expected4.ArrayEquals(actual4));

    207. 

  207. 

    208. 

  208.       string[] expectedc1 = new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P" };

    209. 

  209.       string[] actualc1 = Enumerator.Generate<string>(65, 16, (X) => ((char)X).ToString()).ToArray(16);

    210. 

  210.       Assert.IsTrue(expectedc1.ArrayEquals(actualc1));

    211. 

  211. 

    212. 

  212.       string[,] expectedc2 = new string[,] { { "A", "B", "C", "D", "E", "F", "G", "H" }, { "I", "J", "K", "L", "M", "N", "O", "P" } };

    213. 

  213.       string[,] actualc2 = Enumerator.Generate(65, 16, (X) => ((char)X).ToString()).ToArray(2, 8);

    214. 

  214.       Assert.IsTrue(expected2.ArrayEquals(actual2));

    215. 

  215. 

    216. 

  216.       string[, ,] expectedc3 = new string[,,] { { { "A", "B", "C" }, { "D", "E", "F" }, { "G", "H", "I" } }, { { "J", "K", "L" }, { "M", "N", "O" }, { "P", "Q", "R" } }, { { "S", "T", "U" }, { "V", "W", "X" }, { "Y", "Z", "[" } } };

    217. 

  217.       string[, ,] actualc3 = Enumerator.Generate(65, 27, (X) => ((char)X).ToString()).ToArray(3, 3, 3);

    218. 

  218.       Assert.IsTrue(expectedc3.ArrayEquals(actualc3));

    219. 

  219. 

    220. 

  220.       string[, , ,] expectedc4 = { { { { "A", "B", "C" }, { "D", "E", "F" }, { "G", "H", "I" } }, { { "J", "K", "L" }, { "M", "N", "O" }, { "P", "Q", "R" } } }, { { { "S", "T", "U" }, { "V", "W", "X" }, { "Y", "Z", "[" } }, { { "\\", "]", "^" }, { "_", "`", "a" }, { "b", "c", "d" } } } };

    221. 

  221.       string[, , ,] actualc4 = Enumerator.Generate(65, 36, (X) => ((char)X).ToString()).ToArray(2, 2, 3, 3);

    222. 

  222.       Assert.IsTrue(expectedc4.ArrayEquals(actualc4));

    223. 

  223.     }

    224. 

  224. 

    225. 

  225.     [TestMethod()]

    226. 

  226.     public void AsEnumerableTest()

    227. 

  227.     {

    228. 

  228.       int[, , ,] src1 = Enumerable.Range(0, 625).ToArray(5, 5, 5, 5);

    229. 

  229.       IEnumerable<int> expected1 = Enumerable.Range(0, 625);

    230. 

  230.       Assert.IsTrue(expected1.SequenceEqual(src1.AsEnumerable().OfType<int>()));

    231. 

  231. 

    232. 

  232.       int[][][] src2 = new int[][][] { new int[][] { new int[] { 0, 1, 2, 3 }, new int[] { 4 }, new int[] { 5, 6 } },

    233. 

  233.                                       new int[][] { new int[] { 7, 8 }, new int[] { 9 } },

    234. 

  234.                                       new int[0][] ,

    235. 

  235.                                       new int[][]{ new int[] { 10, 11 }, new int[0], new int[] { 12 } } };

    236. 

  236.       int[] actual2 = src2.AsEnumerable<int>().ToArray();

    237. 

  237.       int[] expected2 = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

    238. 

  238.       Assert.IsTrue(expected2.ArrayEquals(actual2));

    239. 

  239. 

    240. 

  240.       int[] actual2a = ((System.Array)src2).AsEnumerable().OfType<int>().ToArray();

    241. 

  241.       Assert.IsTrue(expected2.ArrayEquals(actual2a));

    242. 

  242.     }

    243. 

  243. 

    244. 

  244.     #endregion

    245. 

  245. 

    246. 

  246.     #region Resize

    247. 

  247. 

    248. 

  248.     private double add(double a, double b)

    249. 

  249.     {

    250. 

  250.       return a + b;

    251. 

  251.     }

    252. 

  252.     private double sub(double a, double b)

    253. 

  253.     {

    254. 

  254.       return a - b;

    255. 

  255.     }

    256. 

  256.     private double mul(double a, double b)

    257. 

  257.     {

    258. 

  258.       return (float)(a * b);

    259. 

  259.     }

    260. 

  260.     private double div(double a, double b)

    261. 

  261.     {

    262. 

  262.       return (float)(a / b);

    263. 

  263.     }

    264. 

  264. 

    265. 

  265.     private float add(float a, float b)

    266. 

  266.     {

    267. 

  267.       return a + b;

    268. 

  268.     }

    269. 

  269.     private float sub(float a, float b)

    270. 

  270.     {

    271. 

  271.       return a - b;

    272. 

  272.     }

    273. 

  273.     private float mul(float a, double b)

    274. 

  274.     {

    275. 

  275.       return (float)(a * b);

    276. 

  276.     }

    277. 

  277.     private float div(float a, double b)

    278. 

  278.     {

    279. 

  279.       return (float)(a / b);

    280. 

  280.     }

    281. 

  281. 

    282. 

  282.     [TestMethod()]

    283. 

  283.     public void Resize1DTest()

    284. 

  284.     {

    285. 

  285.       double[] src = Enumerator.Generate<double>(1, 2, 24).ToArray();

    286. 

  286. 

    287. 

  287.       Assert.IsTrue(src.Resize(7).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.0"), new DoubleComparer(.000001)));

    288. 

  288.       Assert.IsTrue(src.Resize(12).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.1"), new DoubleComparer(.000001)));

    289. 

  289.       Assert.IsTrue(src.Resize(17).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.2"), new DoubleComparer(.000001)));

    290. 

  290.       Assert.IsTrue(src.Resize(24).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.3"), new DoubleComparer(.000001)));

    291. 

  291.       Assert.IsTrue(src.Resize(37).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.4"), new DoubleComparer(.000001)));

    292. 

  292.       Assert.IsTrue(src.Resize(47).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.5"), new DoubleComparer(.000001)));

    293. 

  293. 

    294. 

  294.       Assert.IsTrue(src.Resize(add, sub, mul, div, 7).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.0"), new DoubleComparer(.0001)));

    295. 

  295.       Assert.IsTrue(src.Resize(add, sub, mul, div, 12).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.1"), new DoubleComparer(.0001)));

    296. 

  296.       Assert.IsTrue(src.Resize(add, sub, mul, div, 17).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.2"), new DoubleComparer(.0001)));

    297. 

  297.       Assert.IsTrue(src.Resize(add, sub, mul, div, 24).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.3"), new DoubleComparer(.0001)));

    298. 

  298.       Assert.IsTrue(src.Resize(add, sub, mul, div, 37).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.4"), new DoubleComparer(.0001)));

    299. 

  299.       Assert.IsTrue(src.Resize(add, sub, mul, div, 47).ArrayEquals(ArrayReader.GetDoubleArray("Resize1D-1.0.5"), new DoubleComparer(.0001)));

    300. 

  300. 

    301. 

  301.       float[] src2 = Enumerator.Generate<float>(1, 2, 24).ToArray();

    302. 

  302. 

    303. 

  303.       Assert.IsTrue(src2.Resize(7).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.0"), new SingleComparer(.00001f)));

    304. 

  304.       Assert.IsTrue(src2.Resize(12).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.1"), new SingleComparer(.00001f)));

    305. 

  305.       Assert.IsTrue(src2.Resize(17).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.2"), new SingleComparer(.00001f)));

    306. 

  306.       Assert.IsTrue(src2.Resize(24).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.3"), new SingleComparer(.00001f)));

    307. 

  307.       Assert.IsTrue(src2.Resize(37).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.4"), new SingleComparer(.00001f)));

    308. 

  308.       Assert.IsTrue(src2.Resize(47).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.5"), new SingleComparer(.00001f)));

    309. 

  309. 

    310. 

  310.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 7).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.0"), new SingleComparer(.0001f)));

    311. 

  311.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 12).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.1"), new SingleComparer(.0001f)));

    312. 

  312.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 17).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.2"), new SingleComparer(.0001f)));

    313. 

  313.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 24).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.3"), new SingleComparer(.0001f)));

    314. 

  314.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 37).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.4"), new SingleComparer(.0001f)));

    315. 

  315.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 47).ArrayEquals(ArrayReader.GetSingleArray("Resize1D-1.0.5"), new SingleComparer(.0001f)));

    316. 

  316.     }

    317. 

  317. 

    318. 

  318.     [TestMethod()]

    319. 

  319.     public void Resize2DTest()

    320. 

  320.     {

    321. 

  321.       int r = 3 * 5;

    322. 

  322.       double[,] src = Enumerator.Generate<double>(1, 2, r).ToArray(3, 5);

    323. 

  323. 

    324. 

  324.       Assert.IsTrue(src.Resize(2, 2).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.0"), new DoubleComparer(.000001)));

    325. 

  325.       Assert.IsTrue(src.Resize(2, 12).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.1"), new DoubleComparer(.000001)));

    326. 

  326.       Assert.IsTrue(src.Resize(12, 2).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.2"), new DoubleComparer(.000001)));

    327. 

  327.       Assert.IsTrue(src.Resize(3, 5).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.3"), new DoubleComparer(.000001)));

    328. 

  328.       Assert.IsTrue(src.Resize(12, 12).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.4"), new DoubleComparer(.000001)));

    329. 

  329. 

    330. 

  330.       Assert.IsTrue(src.Resize(add, sub, mul, div, 2, 2).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.0"), new DoubleComparer(.0001)));

    331. 

  331.       Assert.IsTrue(src.Resize(add, sub, mul, div, 2, 12).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.1"), new DoubleComparer(.0001)));

    332. 

  332.       Assert.IsTrue(src.Resize(add, sub, mul, div, 12, 2).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.2"), new DoubleComparer(.0001)));

    333. 

  333.       Assert.IsTrue(src.Resize(add, sub, mul, div, 3, 5).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.3"), new DoubleComparer(.0001)));

    334. 

  334.       Assert.IsTrue(src.Resize(add, sub, mul, div, 12, 12).ArrayEquals(ArrayReader.GetDoubleArray("Resize2D-1.0.4"), new DoubleComparer(.0001)));

    335. 

  335. 

    336. 

  336.       float[,] src2 = Enumerator.Generate<float>(1, 2, r).ToArray(3, 5);

    337. 

  337. 

    338. 

  338.       Assert.IsTrue(src2.Resize(2, 2).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.0"), new SingleComparer(.00001f)));

    339. 

  339.       Assert.IsTrue(src2.Resize(2, 12).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.1"), new SingleComparer(.00001f)));

    340. 

  340.       Assert.IsTrue(src2.Resize(12, 2).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.2"), new SingleComparer(.00001f)));

    341. 

  341.       Assert.IsTrue(src2.Resize(3, 5).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.3"), new SingleComparer(.00001f)));

    342. 

  342.       Assert.IsTrue(src2.Resize(12, 12).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.4"), new SingleComparer(.00001f)));

    343. 

  343. 

    344. 

  344.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 2, 2).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.0"), new SingleComparer(.0001f)));

    345. 

  345.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 2, 12).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.1"), new SingleComparer(.0001f)));

    346. 

  346.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 12, 2).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.2"), new SingleComparer(.0001f)));

    347. 

  347.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 3, 5).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.3"), new SingleComparer(.0001f)));

    348. 

  348.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 12, 12).ArrayEquals(ArrayReader.GetSingleArray("Resize2D-1.0.4"), new SingleComparer(.0001f)));

    349. 

  349.     }

    350. 

  350. 

    351. 

  351.     [TestMethod()]

    352. 

  352.     public void Resize3DTest()

    353. 

  353.     {

    354. 

  354.       int r = 3 * 5 * 7;

    355. 

  355.       double[, ,] src = Enumerator.Generate<double>(1, 2, r).ToArray(3, 5, 7);

    356. 

  356. 

    357. 

  357.       Assert.IsTrue(src.Resize(2, 2, 3).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.0"), new DoubleComparer(.000001)));

    358. 

  358.       Assert.IsTrue(src.Resize(2, 3, 4).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.1"), new DoubleComparer(.000001)));

    359. 

  359.       Assert.IsTrue(src.Resize(5, 7, 11).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.2"), new DoubleComparer(.000001)));

    360. 

  360.       Assert.IsTrue(src.Resize(3, 5, 7).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.3"), new DoubleComparer(.000001)));

    361. 

  361. 

    362. 

  362.       Assert.IsTrue(src.Resize(add, sub, mul, div, 2, 2, 3).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.0"), new DoubleComparer(.0001)));

    363. 

  363.       Assert.IsTrue(src.Resize(add, sub, mul, div, 2, 3, 4).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.1"), new DoubleComparer(.0001)));

    364. 

  364.       Assert.IsTrue(src.Resize(add, sub, mul, div, 5, 7, 11).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.2"), new DoubleComparer(.0001)));

    365. 

  365.       Assert.IsTrue(src.Resize(add, sub, mul, div, 3, 5, 7).ArrayEquals(ArrayReader.GetDoubleArray("Resize3D-1.0.3"), new DoubleComparer(.0001)));

    366. 

  366. 

    367. 

  367.       float[, ,] src2 = Enumerator.Generate<float>(1, 2, r).ToArray(3, 5, 7);

    368. 

  368. 

    369. 

  369.       Assert.IsTrue(src2.Resize(2, 2, 3).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.0"), new SingleComparer(.0001f)));

    370. 

  370.       Assert.IsTrue(src2.Resize(2, 3, 4).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.1"), new SingleComparer(.0001f)));

    371. 

  371.       Assert.IsTrue(src2.Resize(5, 7, 11).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.2"), new SingleComparer(.0001f)));

    372. 

  372.       Assert.IsTrue(src2.Resize(3, 5, 7).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.3"), new SingleComparer(.0001f)));

    373. 

  373. 

    374. 

  374.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 2, 2, 3).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.0"), new SingleComparer(.0001f)));

    375. 

  375.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 2, 3, 4).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.1"), new SingleComparer(.0001f)));

    376. 

  376.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 5, 7, 11).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.2"), new SingleComparer(.0001f)));

    377. 

  377.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 3, 5, 7).ArrayEquals(ArrayReader.GetSingleArray("Resize3D-1.0.3"), new SingleComparer(.0001f)));

    378. 

  378.     }

    379. 

  379. 

    380. 

  380.     [TestMethod()]

    381. 

  381.     public void Resize4DTest()

    382. 

  382.     {

    383. 

  383.       int r = 3 * 5 * 7 * 8;

    384. 

  384.       double[, , ,] src = Enumerator.Generate<double>(1, 2, r).ToArray(3, 5, 7, 8);

    385. 

  385. 

    386. 

  386.       Assert.IsTrue(src.Resize(2, 3, 4, 5).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.0"), new DoubleComparer(.000001)));

    387. 

  387.       Assert.IsTrue(src.Resize(5, 7, 4, 1).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.1"), new DoubleComparer(.000001)));

    388. 

  388.       Assert.IsTrue(src.Resize(3, 5, 7, 8).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.2"), new DoubleComparer(.000001)));

    389. 

  389. 

    390. 

  390.       Assert.IsTrue(src.Resize(add, sub, mul, div, 2, 3, 4, 5).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.0"), new DoubleComparer(.0001)));

    391. 

  391.       Assert.IsTrue(src.Resize(add, sub, mul, div, 5, 7, 4, 1).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.1"), new DoubleComparer(.0001)));

    392. 

  392.       Assert.IsTrue(src.Resize(add, sub, mul, div, 3, 5, 7, 8).ArrayEquals(ArrayReader.GetDoubleArray("Resize4D-1.0.2"), new DoubleComparer(.0001)));

    393. 

  393. 

    394. 

  394.       float[, , ,] src2 = Enumerator.Generate<float>(1, 2, r).ToArray(3, 5, 7, 8);

    395. 

  395. 

    396. 

  396.       Assert.IsTrue(src2.Resize(2, 3, 4, 5).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.0"), new SingleComparer(.0002f)));

    397. 

  397.       Assert.IsTrue(src2.Resize(5, 7, 4, 1).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.1"), new SingleComparer(.0002f)));

    398. 

  398.       Assert.IsTrue(src2.Resize(3, 5, 7, 8).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.2"), new SingleComparer(.0002f)));

    399. 

  399. 

    400. 

  400.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 2, 3, 4, 5).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.0"), new SingleComparer(.0002f)));

    401. 

  401.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 5, 7, 4, 1).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.1"), new SingleComparer(.0002f)));

    402. 

  402.       Assert.IsTrue(src2.Resize(add, sub, mul, div, 3, 5, 7, 8).ArrayEquals(ArrayReader.GetSingleArray("Resize4D-1.0.2"), new SingleComparer(.0002f)));

    403. 

  403.     }

    404. 

  404. 

    405. 

  405.     #endregion

    406. 

  406. 

    407. 

  407.     #region Rotate

    408. 

  408. 

    409. 

  409.     [TestMethod()]

    410. 

  410.     public void Rotate2DTest()

    411. 

  411.     {

    412. 

  412.       int[,] src = Enumerable.Range(0, 12).ToArray(3, 4);

    413. 

  413.       int[,] expectedLeft = new int[,] { { 3, 7, 11 }, { 2, 6, 10 }, { 1, 5, 9 }, { 0, 4, 8 } };

    414. 

  414.       int[,] expectedRight = new int[,] { { 8, 4, 0 }, { 9, 5, 1 }, { 10, 6, 2 }, { 11, 7, 3 } };

    415. 

  415.       int[,] expected180 = new int[,] { { 11, 10, 9, 8 }, { 7, 6, 5, 4 }, { 3, 2, 1, 0 } };

    416. 

  416. 

    417. 

  417.       int[,] actualLeft = src.Rotate(270);

    418. 

  418.       int[,] actualRight = src.Rotate(90);

    419. 

  419.       int[,] actual180 = src.Rotate(180);

    420. 

  420.       int[,] actual000 = src.Rotate(360);

    421. 

  421. 

    422. 

  422.       try

    423. 

  423.       {

    424. 

  424.         src.Rotate(272);

    425. 

  425.         Assert.Fail();

    426. 

  426.       }

    427. 

  427.       catch (System.ArgumentException ex)

    428. 

  428.       { Assert.IsTrue(ex.ParamName == "angle"); }

    429. 

  429.       catch (System.Exception)

    430. 

  430.       { Assert.Fail(); }

    431. 

  431. 

    432. 

  432.       Assert.IsTrue(src.ArrayEquals(src.Rotate(90).Rotate(90).Rotate(90).Rotate(90)));

    433. 

  433.       Assert.IsTrue(src.ArrayEquals(src.Rotate(180).Rotate(90).Rotate(90)));

    434. 

  434.       Assert.IsTrue(src.ArrayEquals(src.Rotate(270).Rotate(90)));

    435. 

  435. 

    436. 

  436.       Assert.IsTrue(expectedLeft.ArrayEquals(actualLeft));

    437. 

  437.       Assert.IsTrue(expectedRight.ArrayEquals(actualRight));

    438. 

  438.       Assert.IsTrue(expected180.ArrayEquals(actual180));

    439. 

  439.       Assert.IsTrue(src.ArrayEquals(actual000));

    440. 

  440.     }

    441. 

  441. 

    442. 

  442.     [TestMethod()]

    443. 

  443.     public void Rotate3DTest()

    444. 

  444.     {

    445. 

  445.       int[, ,] src = Enumerable.Range(0, 24).ToArray(2, 3, 4);

    446. 

  446. 

    447. 

  447.       int[, ,] expected90Z = new int[,,] { { { 8, 4, 0 }, { 9, 5, 1 }, { 10, 6, 2 }, { 11, 7, 3 } }, { { 20, 16, 12 }, { 21, 17, 13 }, { 22, 18, 14 }, { 23, 19, 15 } } };

    448. 

  448.       int[, ,] expected90Y = new int[,,] { { { 3, 15 }, { 7, 19 }, { 11, 23 } }, { { 2, 14 }, { 6, 18 }, { 10, 22 } }, { { 1, 13 }, { 5, 17 }, { 9, 21 } }, { { 0, 12 }, { 4, 16 }, { 8, 20 } } };

    449. 

  449.       int[, ,] expected90X = new int[,,] { { { 12, 13, 14, 15 }, { 0, 1, 2, 3 } }, { { 16, 17, 18, 19 }, { 4, 5, 6, 7 } }, { { 20, 21, 22, 23 }, { 8, 9, 10, 11 } } };

    450. 

  450. 

    451. 

  451.       int[, ,] expected270Z = new int[,,] { { { 3, 7, 11 }, { 2, 6, 10 }, { 1, 5, 9 }, { 0, 4, 8 } }, { { 15, 19, 23 }, { 14, 18, 22 }, { 13, 17, 21 }, { 12, 16, 20 } } };

    452. 

  452.       int[, ,] expected270Y = new int[,,] { { { 12, 0 }, { 16, 4 }, { 20, 8 } }, { { 13, 1 }, { 17, 5 }, { 21, 9 } }, { { 14, 2 }, { 18, 6 }, { 22, 10 } }, { { 15, 3 }, { 19, 7 }, { 23, 11 } } };

    453. 

  453.       int[, ,] expected270X = new int[,,] { { { 8, 9, 10, 11 }, { 20, 21, 22, 23 } }, { { 4, 5, 6, 7 }, { 16, 17, 18, 19 } }, { { 0, 1, 2, 3 }, { 12, 13, 14, 15 } } };

    454. 

  454. 

    455. 

  455.       int[, ,] expected180Z = new int[,,] { { { 11, 10, 9, 8 }, { 7, 6, 5, 4 }, { 3, 2, 1, 0 } }, { { 23, 22, 21, 20 }, { 19, 18, 17, 16 }, { 15, 14, 13, 12 } } };

    456. 

  456.       int[, ,] expected180Y = new int[,,] { { { 15, 14, 13, 12 }, { 19, 18, 17, 16 }, { 23, 22, 21, 20 } }, { { 3, 2, 1, 0 }, { 7, 6, 5, 4 }, { 11, 10, 9, 8 } } };

    457. 

  457.       int[, ,] expected180X = new int[,,] { { { 20, 21, 22, 23 }, { 16, 17, 18, 19 }, { 12, 13, 14, 15 } }, { { 8, 9, 10, 11 }, { 4, 5, 6, 7 }, { 0, 1, 2, 3 } } };

    458. 

  458. 

    459. 

  459.       int[, ,] actual90Z = src.Rotate(RotateAxis.RotateZ, 90);

    460. 

  460.       int[, ,] actual90Y = src.Rotate(RotateAxis.RotateY, 90);

    461. 

  461.       int[, ,] actual90X = src.Rotate(RotateAxis.RotateX, 90);

    462. 

  462. 

    463. 

  463.       int[, ,] actual270Z = src.Rotate(RotateAxis.RotateZ, 270);

    464. 

  464.       int[, ,] actual270Y = src.Rotate(RotateAxis.RotateY, 270);

    465. 

  465.       int[, ,] actual270X = src.Rotate(RotateAxis.RotateX, 270);

    466. 

  466. 

    467. 

  467.       int[, ,] actual180Z = src.Rotate(RotateAxis.RotateZ, 180);

    468. 

  468.       int[, ,] actual180Y = src.Rotate(RotateAxis.RotateY, 180);

    469. 

  469.       int[, ,] actual180X = src.Rotate(RotateAxis.RotateX, 180);

    470. 

  470. 

    471. 

  471.       int[, ,] actual000Z = src.Rotate(RotateAxis.RotateZ, 360);

    472. 

  472.       int[, ,] actual000Y = src.Rotate(RotateAxis.RotateY, 360);

    473. 

  473.       int[, ,] actual000X = src.Rotate(RotateAxis.RotateX, 360);

    474. 

  474. 

    475. 

  475.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    476. 

  476.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    477. 

  477.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 270).Rotate(RotateAxis.RotateX, 90)));

    478. 

  478. 

    479. 

  479.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    480. 

  480.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    481. 

  481.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 270).Rotate(RotateAxis.RotateY, 90)));

    482. 

  482. 

    483. 

  483.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    484. 

  484.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    485. 

  485.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 270).Rotate(RotateAxis.RotateZ, 90)));

    486. 

  486. 

    487. 

  487.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateZ, 90)

    488. 

  488.                                        .Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateZ, 90)

    489. 

  489.                                        .Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateZ, 90)

    490. 

  490.                                        .Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateZ, 90)));

    491. 

  491.       try

    492. 

  492.       {

    493. 

  493.         src.Rotate(RotateAxis.RotateX, 272);

    494. 

  494.         Assert.Fail();

    495. 

  495.       }

    496. 

  496.       catch (System.ArgumentException ex)

    497. 

  497.       { Assert.IsTrue(ex.ParamName == "angle"); }

    498. 

  498.       catch (System.Exception)

    499. 

  499.       { Assert.Fail(); }

    500. 

  500. 

    501. 

  501.       try

    502. 

  502.       {

    503. 

  503.         src.Rotate(RotateAxis.RotateA, 180);

    504. 

  504.         Assert.Fail();

    505. 

  505.       }

    506. 

  506.       catch (System.ArgumentException ex)

    507. 

  507.       { Assert.IsTrue(ex.ParamName == "axis"); }

    508. 

  508.       catch (System.Exception)

    509. 

  509.       { Assert.Fail(); }

    510. 

  510. 

    511. 

  511.       Assert.IsTrue(expected90Z.ArrayEquals(actual90Z));

    512. 

  512.       Assert.IsTrue(expected90Y.ArrayEquals(actual90Y));

    513. 

  513.       Assert.IsTrue(expected90X.ArrayEquals(actual90X));

    514. 

  514. 

    515. 

  515.       Assert.IsTrue(expected270Z.ArrayEquals(actual270Z));

    516. 

  516.       Assert.IsTrue(expected270Y.ArrayEquals(actual270Y));

    517. 

  517.       Assert.IsTrue(expected270X.ArrayEquals(actual270X));

    518. 

  518. 

    519. 

  519.       Assert.IsTrue(expected180Z.ArrayEquals(actual180Z));

    520. 

  520.       Assert.IsTrue(expected180Y.ArrayEquals(actual180Y));

    521. 

  521.       Assert.IsTrue(expected180X.ArrayEquals(actual180X));

    522. 

  522. 

    523. 

  523.       Assert.IsTrue(src.ArrayEquals(actual000Z));

    524. 

  524.       Assert.IsTrue(src.ArrayEquals(actual000Y));

    525. 

  525.       Assert.IsTrue(src.ArrayEquals(actual000X));

    526. 

  526. 

    527. 

  527.     }

    528. 

  528. 

    529. 

  529.     [TestMethod()]

    530. 

  530.     public void Rotate4DTest()

    531. 

  531.     {

    532. 

  532.       int[, , ,] src = Enumerable.Range(0, 360).ToArray(3, 4, 5, 6);

    533. 

  533. 

    534. 

  534.       try

    535. 

  535.       {

    536. 

  536.         src.Rotate(RotateAxis.RotateX, 272);

    537. 

  537.         Assert.Fail();

    538. 

  538.       }

    539. 

  539.       catch (System.ArgumentException ex)

    540. 

  540.       { Assert.IsTrue(ex.ParamName == "angle"); }

    541. 

  541.       catch (System.Exception)

    542. 

  542.       { Assert.Fail(); }

    543. 

  543. 

    544. 

  544.       try

    545. 

  545.       {

    546. 

  546.         src.Rotate(RotateAxis.RotateB, 180);

    547. 

  547.         Assert.Fail();

    548. 

  548.       }

    549. 

  549.       catch (System.ArgumentException ex)

    550. 

  550.       { Assert.IsTrue(ex.ParamName == "axis"); }

    551. 

  551.       catch (System.Exception)

    552. 

  552.       { Assert.Fail(); }

    553. 

  553. 

    554. 

  554.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    555. 

  555.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    556. 

  556.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 270).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    557. 

  557.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 360).Rotate(RotateAxis.RotateX, 90).Rotate(RotateAxis.RotateX, 90)));

    558. 

  558.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 450).Rotate(RotateAxis.RotateX, 90)));

    559. 

  559. 

    560. 

  560.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    561. 

  561.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    562. 

  562.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 270).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    563. 

  563.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 360).Rotate(RotateAxis.RotateY, 90).Rotate(RotateAxis.RotateY, 90)));

    564. 

  564.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateY, 450).Rotate(RotateAxis.RotateY, 90)));

    565. 

  565. 

    566. 

  566.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    567. 

  567.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    568. 

  568.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 270).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    569. 

  569.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 360).Rotate(RotateAxis.RotateZ, 90).Rotate(RotateAxis.RotateZ, 90)));

    570. 

  570.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateZ, 450).Rotate(RotateAxis.RotateZ, 90)));

    571. 

  571. 

    572. 

  572.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90)));

    573. 

  573.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 180).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90)));

    574. 

  574.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 270).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90)));

    575. 

  575.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 360).Rotate(RotateAxis.RotateA, 90).Rotate(RotateAxis.RotateA, 90)));

    576. 

  576.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 450).Rotate(RotateAxis.RotateA, 90)));

    577. 

  577. 

    578. 

  578.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateA, 180)

    579. 

  579.                                        .Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateA, 180)

    580. 

  580.                                        .Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateA, 180)

    581. 

  581.                                        .Rotate(RotateAxis.RotateX, 180).Rotate(RotateAxis.RotateY, 180).Rotate(RotateAxis.RotateZ, 180).Rotate(RotateAxis.RotateA, 180)));

    582. 

  582. 

    583. 

  583.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateA, 540 + 270).Rotate(RotateAxis.RotateA, 270)));

    584. 

  584. 

    585. 

  585.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateNone, 450)));

    586. 

  586.       Assert.IsTrue(src.ArrayEquals(src.Rotate(RotateAxis.RotateNone, 540)));

    587. 

  587.     }

    588. 

  588. 

    589. 

  589.     #endregion

    590. 

  590. 

    591. 

  591.     #region Flip

    592. 

  592. 

    593. 

  593.     [TestMethod()]

    594. 

  594.     public void Flip1DTest()

    595. 

  595.     {

    596. 

  596.       double[] src = Enumerator.Generate<double>(0, 1, 12).ToArray();

    597. 

  597. 

    598. 

  598.       Assert.IsTrue(src.Flip().ArrayEquals(ArrayReader.GetDoubleArray("Flip1D-1")));

    599. 

  599.     }

    600. 

  600. 

    601. 

  601.     [TestMethod()]

    602. 

  602.     public void Flip2DTest()

    603. 

  603.     {

    604. 

  604.       double[,] src = Enumerator.Generate<double>(0, 1, 12).ToArray(3, 4);

    605. 

  605. 

    606. 

  606.       Assert.IsTrue(src.Flip(FlipAxis.None).ArrayEquals(src));

    607. 

  607.       Assert.IsTrue(src.Flip(FlipAxis.FlipX).ArrayEquals(ArrayReader.GetDoubleArray("Flip2D-1.X")));

    608. 

  608.       Assert.IsTrue(src.Flip(FlipAxis.FlipY).ArrayEquals(ArrayReader.GetDoubleArray("Flip2D-1.Y")));

    609. 

  609.       Assert.IsTrue(src.Flip(FlipAxis.FlipXY).ArrayEquals(ArrayReader.GetDoubleArray("Flip2D-1.XY")));

    610. 

  610. 

    611. 

  611.       try

    612. 

  612.       {

    613. 

  613.         src.Flip(FlipAxis.FlipZ);

    614. 

  614.         Assert.Fail();

    615. 

  615.       }

    616. 

  616.       catch (System.ArgumentException ex)

    617. 

  617.       {

    618. 

  618.         Assert.IsTrue(ex.ParamName == "axis");

    619. 

  619.       }

    620. 

  620.       catch

    621. 

  621.       {

    622. 

  622.         Assert.Fail();

    623. 

  623.       }

    624. 

  624.     }

    625. 

  625. 

    626. 

  626.     [TestMethod()]

    627. 

  627.     public void Flip3DTest()

    628. 

  628.     {

    629. 

  629.       double[, ,] src = Enumerator.Generate<double>(0, 1, 24).ToArray(2, 3, 4);

    630. 

  630. 

    631. 

  631.       Assert.IsTrue(src.Flip(FlipAxis.None).ArrayEquals(src));

    632. 

  632.       Assert.IsTrue(src.Flip(FlipAxis.FlipX).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.X")));

    633. 

  633.       Assert.IsTrue(src.Flip(FlipAxis.FlipY).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.Y")));

    634. 

  634.       Assert.IsTrue(src.Flip(FlipAxis.FlipZ).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.Z")));

    635. 

  635. 

    636. 

  636.       Assert.IsTrue(src.Flip(FlipAxis.FlipXY).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.XY")));

    637. 

  637.       Assert.IsTrue(src.Flip(FlipAxis.FlipXZ).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.XZ")));

    638. 

  638.       Assert.IsTrue(src.Flip(FlipAxis.FlipYZ).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.YZ")));

    639. 

  639. 

    640. 

  640.       Assert.IsTrue(src.Flip(FlipAxis.FlipXYZ).ArrayEquals(ArrayReader.GetDoubleArray("Flip3D-1.XYZ")));

    641. 

  641. 

    642. 

  642.       try

    643. 

  643.       {

    644. 

  644.         src.Flip((FlipAxis)63);

    645. 

  645.         Assert.Fail();

    646. 

  646.       }

    647. 

  647.       catch (System.ArgumentException ex)

    648. 

  648.       {

    649. 

  649.         Assert.IsTrue(ex.ParamName == "axis");

    650. 

  650.       }

    651. 

  651.       catch

    652. 

  652.       {

    653. 

  653.         Assert.Fail();

    654. 

  654.       }

    655. 

  655. 

    656. 

  656.     }

    657. 

  657.     #endregion

    658. 

  658. 

    659. 

  659.     #region Replace and Extract

    660. 

  660. 

    661. 

  661.     [TestMethod()]

    662. 

  662.     public void Replace1Test()

    663. 

  663.     {

    664. 

  664.       int[] src1 = Enumerable.Range(0, 12).ToArray(12);

    665. 

  665.       int[] src2 = Enumerable.Range(991, 3).ToArray(3);

    666. 

  666. 

    667. 

  667.       int[] expected = Enumerable.Range(0, 12).ToArray(12);

    668. 

  668.       int offset = 3;

    669. 

  669.       for (int i = 0; i < src2.Length; i++)

    670. 

  670.         expected[i + offset] = src2[i];

    671. 

  671. 

    672. 

  672.       src1.Replace(src2, offset);

    673. 

  673.       Assert.IsTrue(expected.ArrayEquals(src1));

    674. 

  674.     }

    675. 

  675. 

    676. 

  676.     [TestMethod()]

    677. 

  677.     public void Replace2Test()

    678. 

  678.     {

    679. 

  679.       int[,] src1 = Enumerable.Range(0, 12).ToArray(3, 4);

    680. 

  680.       int[,] src2 = Enumerable.Range(991, 4).ToArray(2, 2);

    681. 

  681. 

    682. 

  682.       int[,] expected = new int[,] { { 0, 1, 2, 3 }, { 4, 5, 991, 992 }, { 8, 9, 993, 994 } };

    683. 

  683. 

    684. 

  684.       int offsetX = 2;

    685. 

  685.       int offsetY = 1;

    686. 

  686. 

    687. 

  687.       src1.Replace(src2, offsetY, offsetX);

    688. 

  688.       Assert.IsTrue(expected.ArrayEquals(src1));

    689. 

  689.     }

    690. 

  690. 

    691. 

  691.     [TestMethod()]

    692. 

  692.     public void Replace3Test()

    693. 

  693.     {

    694. 

  694.       int[, ,] src1 = Enumerable.Range(0, 27).ToArray(3, 3, 3);

    695. 

  695.       int[, ,] src2 = Enumerable.Range(991, 8).ToArray(2, 2, 2);

    696. 

  696. 

    697. 

  697.       int[, ,] expected = new int[,,] { { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 } }, { { 9, 10, 11 }, { 12, 991, 992 }, { 15, 993, 994 } }, { { 18, 19, 20 }, { 21, 995, 996 }, { 24, 997, 998 } } };

    698. 

  698. 

    699. 

  699.       int offsetX = 1;

    700. 

  700.       int offsetY = 1;

    701. 

  701.       int offsetZ = 1;

    702. 

  702. 

    703. 

  703.       src1.Replace(src2, offsetZ, offsetY, offsetX);

    704. 

  704.       Assert.IsTrue(expected.ArrayEquals(src1));

    705. 

  705.     }

    706. 

  706. 

    707. 

  707.     [TestMethod()]

    708. 

  708.     public void Replace4Test()

    709. 

  709.     {

    710. 

  710.       int[, , ,] src1 = Enumerable.Range(0, 36).ToArray(2, 2, 3, 3);

    711. 

  711.       int[, , ,] src2 = Enumerable.Range(981, 16).ToArray(2, 2, 2, 2);

    712. 

  712. 

    713. 

  713.       int[, , ,] expected = new int[,,,] { { { { 0, 1, 2 }, { 3, 981, 982 }, { 6, 983, 984 } }, { { 9, 10, 11 }, { 12, 985, 986 }, { 15, 987, 988 } } }, { { { 18, 19, 20 }, { 21, 989, 990 }, { 24, 991, 992 } }, { { 27, 28, 29 }, { 30, 993, 994 }, { 33, 995, 996 } } } };

    714. 

  714. 

    715. 

  715.       int offsetX = 1;

    716. 

  716.       int offsetY = 1;

    717. 

  717.       int offsetZ = 0;

    718. 

  718.       int offsetA = 0;

    719. 

  719. 

    720. 

  720.       src1.Replace(src2, offsetZ, offsetA, offsetY, offsetX);

    721. 

  721.       Assert.IsTrue(expected.ArrayEquals(src1));

    722. 

  722.     }

    723. 

  723. 

    724. 

  724.     [TestMethod()]

    725. 

  725.     public void Extract1Test()

    726. 

  726.     {

    727. 

  727.       int[] src1 = Enumerable.Range(0, 12).ToArray(12);

    728. 

  728.       int[] expected = Enumerable.Range(3, 4).ToArray(4);

    729. 

  729.       int offset = 3;

    730. 

  730. 

    731. 

  731.       Assert.IsTrue(src1.Extract(offset, 4).ArrayEquals(expected));

    732. 

  732.     }

    733. 

  733. 

    734. 

  734.     [TestMethod()]

    735. 

  735.     public void Extract2Test()

    736. 

  736.     {

    737. 

  737.       double[,] src1 = (double[,])ArrayReader.GetDoubleArray("Extract3-0");

    738. 

  738.       double[,] expected = Enumerator.Generate<double>(991, 1, 4).ToArray(2, 2);

    739. 

  739.       double[,] expected2 = new double[,] { { 5, 991 }, { 9, 993 } };

    740. 

  740. 

    741. 

  741.       int offsetX = 2;

    742. 

  742.       int offsetY = 1;

    743. 

  743. 

    744. 

  744.       Assert.IsTrue(src1.Extract(offsetY, offsetX, 2, 2).ArrayEquals(expected));

    745. 

  745. 

    746. 

  746.       offsetX = 1;

    747. 

  747.       offsetY = 1;

    748. 

  748. 

    749. 

  749.       Assert.IsTrue(src1.Extract(offsetY, offsetX, 2, 2).ArrayEquals(expected2));

    750. 

  750.     }

    751. 

  751. 

    752. 

  752.     [TestMethod()]

    753. 

  753.     public void Extract3Test()

    754. 

  754.     {

    755. 

  755.       double[, ,] src1 = (double[, ,])ArrayReader.GetDoubleArray("Extract3-1");

    756. 

  756.       double[, ,] expected = Enumerator.Generate<double>(991, 1, 8).ToArray(2, 2, 2);

    757. 

  757. 

    758. 

  758.       int offsetX = 1;

    759. 

  759.       int offsetY = 1;

    760. 

  760.       int offsetZ = 1;

    761. 

  761. 

    762. 

  762.       Assert.IsTrue(src1.Extract(offsetZ, offsetY, offsetX, 2, 2, 2).ArrayEquals(expected));

    763. 

  763.     }

    764. 

  764. 

    765. 

  765.     [TestMethod()]

    766. 

  766.     public void Extract4Test()

    767. 

  767.     {

    768. 

  768.       double[, , ,] src1 = (double[, , ,])ArrayReader.GetDoubleArray("Extract4-1");

    769. 

  769.       double[, , ,] expected = Enumerator.Generate<double>(981, 1, 16).ToArray(2, 2, 2, 2);

    770. 

  770. 

    771. 

  771.       int offsetX = 1;

    772. 

  772.       int offsetY = 1;

    773. 

  773.       int offsetZ = 0;

    774. 

  774.       int offsetA = 0;

    775. 

  775. 

    776. 

  776.       Assert.IsTrue(src1.Extract(offsetA, offsetZ, offsetY, offsetX, 2, 2, 2, 2).ArrayEquals(expected));

    777. 

  777.     }

    778. 

  778.     #endregion

    779. 

  779. 

    780. 

  780.     #region Jagged / Fixed Converters

    781. 

  781. 

    782. 

  782.     [TestMethod()]

    783. 

  783.     public void ToFromJagged2DTest()

    784. 

  784.     {

    785. 

  785.       int[][] arr = new int[7][];

    786. 

  786. 

    787. 

  787.       arr[0] = new int[] { 1, 2, 3, 4, 5 };

    788. 

  788.       arr[1] = null;

    789. 

  789.       arr[2] = new int[0];

    790. 

  790.       arr[3] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    791. 

  791.       arr[4] = new int[] { 1, 2, 3 };

    792. 

  792.       arr[5] = new int[0];

    793. 

  793.       arr[6] = null;

    794. 

  794. 

    795. 

  795.       int[,] actual1 = arr.FromJagged();

    796. 

  796. 

    797. 

  797.       int[,] expected1 = new int[,] { { 1, 2, 3, 4, 5, 0, 0, 0, 0 }, 

    798. 

  798.                                       { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 

    799. 

  799.                                       { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 

    800. 

  800.                                       { 1, 2, 3, 4, 5, 6, 7, 8, 9 },

    801. 

  801.                                       { 1, 2, 3, 0, 0, 0, 0, 0, 0 },

    802. 

  802.                                       { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 

    803. 

  803.                                       { 0, 0, 0, 0, 0, 0, 0, 0, 0 } };

    804. 

  804. 

    805. 

  805.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    806. 

  806. 

    807. 

  807.       int[,] actual2 = arr.FromJagged(4, 6);

    808. 

  808. 

    809. 

  809.       int[,] expected2 = new int[,] { { 1, 2, 3, 4, 5, 0 }, 

    810. 

  810.                                       { 0, 0, 0, 0, 0, 0 }, 

    811. 

  811.                                       { 0, 0, 0, 0, 0, 0 }, 

    812. 

  812.                                       { 1, 2, 3, 4, 5, 6 } };

    813. 

  813. 

    814. 

  814.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    815. 

  815. 

    816. 

  816.       int[][] actualRT = actual1.ToJagged();

    817. 

  817. 

    818. 

  818.       int[][] expectedRT = arr;

    819. 

  819. 

    820. 

  820.       for (int i = 0; i < actualRT.Length; i++)

    821. 

  821.         if (actualRT[i] != null)

    822. 

  822.           Assert.IsTrue((actualRT[i].Length == 0 && expectedRT[i] == null) || actualRT[i].ArrayEquals(expectedRT[i]));

    823. 

  823. 

    824. 

  824.       int[][] actualRF = actual1.ToJagged(false);

    825. 

  825. 

    826. 

  826.       int[][] expectedRF = new int[7][];

    827. 

  827.       expectedRF[0] = new int[] { 1, 2, 3, 4, 5, 0, 0, 0, 0 };

    828. 

  828.       expectedRF[1] = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    829. 

  829.       expectedRF[2] = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    830. 

  830.       expectedRF[3] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    831. 

  831.       expectedRF[4] = new int[] { 1, 2, 3, 0, 0, 0, 0, 0, 0 };

    832. 

  832.       expectedRF[5] = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    833. 

  833.       expectedRF[6] = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    834. 

  834. 

    835. 

  835.       for (int i = 0; i < actualRF.Length; i++)

    836. 

  836.         Assert.IsTrue(actualRF[i].ArrayEquals(expectedRF[i]));

    837. 

  837.     }

    838. 

  838. 

    839. 

  839.     [TestMethod()]

    840. 

  840.     public void ToFromJagged3DTest()

    841. 

  841.     {

    842. 

  842.       int[][][] arr = GetJagged3DArray();

    843. 

  843. 

    844. 

  844.       int[, ,] actual1 = arr.FromJagged();

    845. 

  845. 

    846. 

  846.       int[, ,] expected1 = new int[,,] { { { 1, 2, 3, 4, 5, 0 }, { 0, 0, 0, 0, 0, 0 }, { 1, 2, 3, 0, 0, 0 } }, 

    847. 

  847.                                          { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } },

    848. 

  848.                                          { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } },

    849. 

  849.                                          { { 1, 2, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0 }, { 1, 2, 0, 0, 0, 0 } },

    850. 

  850.                                          { { 1, 2, 3, 4, 5, 6 }, { 1, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } },

    851. 

  851.                                          { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } },

    852. 

  852.                                          { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } } };

    853. 

  853. 

    854. 

  854.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    855. 

  855. 

    856. 

  856.       int[, ,] actual2 = arr.FromJagged(4, 2, 3);

    857. 

  857. 

    858. 

  858.       int[, ,] expected2 = new int[,,] { { { 1, 2, 3 }, { 0, 0, 0 } }, 

    859. 

  859.                                          { { 0, 0, 0 }, { 0, 0, 0 } },

    860. 

  860.                                          { { 0, 0, 0 }, { 0, 0, 0 } },

    861. 

  861.                                          { { 1, 2, 0 }, { 1, 0, 0 } } };

    862. 

  862. 

    863. 

  863.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    864. 

  864. 

    865. 

  865.       int[][][] actualRT = actual1.ToJagged();

    866. 

  866.       int[][][] expectedRT = arr;

    867. 

  867. 

    868. 

  868.       for (int i1 = 0; i1 < actualRT.Length; i1++)

    869. 

  869.         if (actualRT[i1] != null)

    870. 

  870.           for (int i2 = 0; i2 < actualRT[i1].Length; i2++)

    871. 

  871.             if (actualRT[i1][i2] != null)

    872. 

  872.               Assert.IsTrue((actualRT[i1][i2].Length == 0 && expectedRT[i1][i2] == null) || actualRT[i1][i2].ArrayEquals(expectedRT[i1][i2]));

    873. 

  873. 

    874. 

  874.       int[][][] actualRF = actual1.ToJagged(false);

    875. 

  875. 

    876. 

  876.       int[][][] expectedRF = GetJagged3DArray2();

    877. 

  877. 

    878. 

  878.       for (int i1 = 0; i1 < actualRF.Length; i1++)

    879. 

  879.         if (actualRF[i1] != null)

    880. 

  880.           for (int i2 = 0; i2 < actualRF[i1].Length; i2++)

    881. 

  881.             if (actualRF[i1][i2] != null)

    882. 

  882.               Assert.IsTrue((actualRF[i1][i2].Length == 0 && expectedRF[i1][i2] == null) || actualRF[i1][i2].ArrayEquals(expectedRF[i1][i2]));

    883. 

  883.     }

    884. 

  884. 

    885. 

  885.     [TestMethod()]

    886. 

  886.     public void ToFromJagged4DTest()

    887. 

  887.     {

    888. 

  888.       int[][][][] arr = new int[][][][] { GetJagged3DArray(), null, new int[0][][], GetJagged3DArray() };

    889. 

  889. 

    890. 

  890.       int[, , ,] actual1 = arr.FromJagged();

    891. 

  891. 

    892. 

  892.       int[, , ,] expected1 = new int[,,,] { { { { 1, 2, 3, 4, 5, 0 }, { 0, 0, 0, 0, 0, 0 }, { 1, 2, 3, 0, 0, 0 } }, 

    893. 

  893.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    894. 

  894.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    895. 

  895.                                               { { 1, 2, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0 }, { 1, 2, 0, 0, 0, 0 } }, 

    896. 

  896.                                               { { 1, 2, 3, 4, 5, 6 }, { 1, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    897. 

  897.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    898. 

  898.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } } },

    899. 

  899.                                             { { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    900. 

  900.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    901. 

  901.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    902. 

  902.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    903. 

  903.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    904. 

  904.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    905. 

  905.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } } },                                                  

    906. 

  906.                                             { { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    907. 

  907.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    908. 

  908.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    909. 

  909.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    910. 

  910.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    911. 

  911.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    912. 

  912.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } } },

    913. 

  913.                                             { { { 1, 2, 3, 4, 5, 0 }, { 0, 0, 0, 0, 0, 0 }, { 1, 2, 3, 0, 0, 0 } }, 

    914. 

  914.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    915. 

  915.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    916. 

  916.                                               { { 1, 2, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0 }, { 1, 2, 0, 0, 0, 0 } }, 

    917. 

  917.                                               { { 1, 2, 3, 4, 5, 6 }, { 1, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    918. 

  918.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 

    919. 

  919.                                               { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } } } };

    920. 

  920. 

    921. 

  921.       Assert.IsTrue(actual1.ArrayEquals(expected1));

    922. 

  922. 

    923. 

  923.       int[, , ,] actual2 = arr.FromJagged(2, 4, 2, 3);

    924. 

  924. 

    925. 

  925.       int[, , ,] expected2 = new int[,,,] { { { { 1, 2, 3 }, { 0, 0, 0 } },

    926. 

  926.                                               { { 0, 0, 0 }, { 0, 0, 0 } }, 

    927. 

  927.                                               { { 0, 0, 0 }, { 0, 0, 0 } }, 

    928. 

  928.                                               { { 1, 2, 0 }, { 1, 0, 0 } } },

    929. 

  929.                                             { { { 0, 0, 0 }, { 0, 0, 0 } }, 

    930. 

  930.                                               { { 0, 0, 0 }, { 0, 0, 0 } }, 

    931. 

  931.                                               { { 0, 0, 0 }, { 0, 0, 0 } }, 

    932. 

  932.                                               { { 0, 0, 0 }, { 0, 0, 0 } } } };

    933. 

  933. 

    934. 

  934.       Assert.IsTrue(actual2.ArrayEquals(expected2));

    935. 

  935. 

    936. 

  936.       int[][][][] actualRT = actual1.ToJagged();

    937. 

  937.       int[][][][] expectedRT = arr;

    938. 

  938. 

    939. 

  939.       for (int i1 = 0; i1 < actualRT.Length; i1++)

    940. 

  940.         if (actualRT[i1] != null)

    941. 

  941.           for (int i2 = 0; i2 < actualRT[i1].Length; i2++)

    942. 

  942.             if (actualRT[i1][i2] != null)

    943. 

  943.               for (int i3 = 0; i3 < actualRT[i1][i2].Length; i3++)

    944. 

  944.                 if (actualRT[i1][i2][i3] != null)

    945. 

  945.                   Assert.IsTrue((actualRT[i1][i2][i3].Length == 0 && expectedRT[i1][i2][i3] == null) || actualRT[i1][i2][i3].ArrayEquals(expectedRT[i1][i2][i3]));

    946. 

  946. 

    947. 

  947.       int[][][][] actualRF = actual1.ToJagged(false);

    948. 

  948.       int[][][][] expectedRF = new int[][][][] { GetJagged3DArray2(), GetJagged3DArray3(), GetJagged3DArray3(), GetJagged3DArray2() };

    949. 

  949. 

    950. 

  950.       for (int i1 = 0; i1 < actualRF.Length; i1++)

    951. 

  951.         if (actualRF[i1] != null)

    952. 

  952.           for (int i2 = 0; i2 < actualRF[i1].Length; i2++)

    953. 

  953.             if (actualRF[i1][i2] != null)

    954. 

  954.               for (int i3 = 0; i3 < actualRF[i1][i2].Length; i3++)

    955. 

  955.                 if (actualRF[i1][i2][i3] != null)

    956. 

  956.                   Assert.IsTrue((actualRF[i1][i2][i3].Length == 0 && expectedRF[i1][i2][i3] == null) || actualRF[i1][i2][i3].ArrayEquals(expectedRF[i1][i2][i3]));

    957. 

  957.     }

    958. 

  958. 

    959. 

  959.     private int[][][] GetJagged3DArray()

    960. 

  960.     {

    961. 

  961.       int[][][] arr = new int[7][][];

    962. 

  962.       arr[0] = new int[3][] { new int[] { 1, 2, 3, 4, 5 }, new int[] { }, new int[] { 1, 2, 3 } };

    963. 

  963.       arr[1] = null;

    964. 

  964.       arr[2] = new int[0][];

    965. 

  965.       arr[3] = new int[3][] { new int[] { 1, 2 }, new int[] { 1 }, new int[] { 1, 2 } };

    966. 

  966.       arr[4] = new int[2][] { new int[] { 1, 2, 3, 4, 5, 6 }, new int[] { 1 } };

    967. 

  967.       arr[5] = new int[0][];

    968. 

  968.       arr[6] = null;

    969. 

  969.       return arr;

    970. 

  970.     }

    971. 

  971. 

    972. 

  972.     private static int[][][] GetJagged3DArray2()

    973. 

  973.     {

    974. 

  974.       int[][][] arr = new int[7][][];

    975. 

  975.       arr[0] = new int[3][] { new int[] { 1, 2, 3, 4, 5, 0 }, new int[] { 0, 0, 0, 0, 0, 0 }, new int[] { 1, 2, 3, 0, 0, 0 } };

    976. 

  976.       arr[1] = new int[3][] { new int[] { 0, 0, 0, 0, 0, 0 }, new int[] { 0, 0, 0, 0, 0, 0 }, new int[] { 0, 0, 0, 0, 0, 0 } };

    977. 

  977.       arr[2] = new i…
    978.