public void TestMultiDimIntArray_Values()
{
int val = 0;
int[,,] sarr1 = new int[2, 3, 5];
IterateArrayWithValues(sarr1, 0, new int[sarr1.Rank], ref val);
var doc = XmlSerializer.Serialize(sarr1, 1, "test1");
//Debug.Log("Save: " + Application.persistentDataPath + "/test.xml");
//doc.Save(Application.persistentDataPath + "/test.xml");
int[,,] darr1 = XmlDeserializer.Deserialize(doc.InnerXml, 1) as int[, , ];
Assert.NotNull(darr1);
Assert.AreNotSame(sarr1, darr1);
Assert.AreEqual(3, darr1.Rank);
Assert.AreEqual(2, darr1.GetLength(0));
Assert.AreEqual(3, darr1.GetLength(1));
Assert.AreEqual(5, darr1.GetLength(2));
//manually test individual elements
Assert.AreEqual(2, darr1.GetValue(0, 0, 1));
Assert.AreEqual(6, darr1.GetValue(0, 1, 0));
Assert.AreEqual(22, darr1.GetValue(1, 1, 1));
}
/// <summary>
/// 输出矩阵
/// </summary>
/// <param name="name"></param>
/// <param name="matrix"></param>
static void PrintMatrix(string name, int[,,] matrix)
{
Console.WriteLine("{0}: [{1}, {2}, {3}]", name, matrix.GetLength(0), matrix.GetLength(1), matrix.GetLength(2));
for (var i = 0; i < matrix.GetLength(0); i++)
{
for (var j = 0; j < matrix.GetLength(1); j++)
{
for (var k = 0; k < matrix.GetLength(2); k++)
{
Console.Write("{0},", matrix.GetValue(i, j, k));
}
Console.WriteLine();
}
Console.WriteLine();
}
}
public void MultiDimensionalArray()
{
int[,,] multiArray = new int[2, 3, 4];
multiArray[1, 2, 3] = 7698;
multiArray[0, 1, 1] = 278;
multiArray[0, 0, 0] = 325;
byte[] data = BytesStream.Serialize(multiArray);
int[,,] decod = BytesStream.Deserialize <int[, , ]>(data);
Assert.AreEqual(multiArray.Length, decod.Length);
var arrayIndex = new ArrayIterator(new int[] { 2, 3, 4 });
for (int i = 0; i < multiArray.Length; i++)
{
int[] indices = arrayIndex.GetNext();
Assert.AreEqual(multiArray.GetValue(indices), decod.GetValue(indices));
}
}
static void Main()
{
int[,] twoDim = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 } };
for (int i = twoDim.GetLowerBound(0); i <= twoDim.GetUpperBound(0); ++i)
{
for (int j = twoDim.GetLowerBound(1); j <= twoDim.GetUpperBound(1); ++j)
{
Console.WriteLine(twoDim[i, j]);
}
}
//https://msdn.microsoft.com/tr-tr/library/system.array.getlowerbound(v=vs.110).aspx
// Create a one-dimensional integer array.
int[] integers = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
// Get the upper and lower bound of the array.
int upper = integers.GetUpperBound(0);
int lower = integers.GetLowerBound(0);
Console.WriteLine("Elements from index {0} to {1}:", lower, upper);
// Iterate the array.
for (int ctr = lower; ctr <= upper; ctr++)
{
Console.Write("{0}{1}{2}", ctr == lower ? " " : "",
integers[ctr],
ctr < upper ? ", " : Environment.NewLine);
}
Console.WriteLine();
// Two-dimensional array.
// Create a two-dimensional integer array.
int[,] integers2d = { { 2, 4 }, { 3, 9 }, { 4, 16 }, { 5, 25 },
{ 6, 36 }, { 7, 49 }, { 8, 64 }, { 9, 81 } };
// Get the number of dimensions.
int rank = integers2d.Rank;
Console.WriteLine("Number of dimensions: {0}", rank);
for (int ctr = 0; ctr < integers2d.Rank - 1; ctr++)
{
Console.WriteLine(" Dimension {0}: from {1} to {2}", ctr, integers2d.GetLowerBound(ctr), integers2d.GetUpperBound(ctr));
}
// Iterate the 2-dimensional array and display its values.
Console.WriteLine(" Values of array elements:");
for (int outer = integers2d.GetLowerBound(0); outer <= integers2d.GetUpperBound(0); outer++)
{
for (int inner = integers2d.GetLowerBound(1); inner <= integers2d.GetUpperBound(1); inner++)
{
Console.WriteLine(" {3}{0}, {1}{4} = {2}", outer, inner, integers2d.GetValue(outer, inner), "{", "}");
}
}
Console.WriteLine(" {4}{0}, {1}, {2}{5} = {3}", 0, 1, 2, 3, "{", "}");
// Three-dimensional array.
int[, ,] integer3d =
{
{ { 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 } }
};
// Get the number of dimensions
rank = integer3d.Rank;
Console.WriteLine("Number of dimensions: {0}", rank);
for (int ctr = 0; ctr < integer3d.Rank - 1; ctr++)
{
Console.WriteLine(" Dimension {0}: from {1} to {2}", ctr, integer3d.GetLowerBound(ctr), integer3d.GetUpperBound(ctr));
}
for (int outer = integer3d.GetLowerBound(0); outer <= integer3d.GetUpperBound(0); outer++)
{
for (int inner = integer3d.GetLowerBound(1); inner <= integer3d.GetUpperBound(1); inner++)
{
for (int innerr = integer3d.GetLowerBound(2); innerr <= integer3d.GetUpperBound(2); innerr++)
{
Console.WriteLine(" {4}{0}, {1}, {2}{5} = {3}", outer, inner, innerr, integer3d.GetValue(outer, inner, innerr), "{", "}");
}
}
}
Console.ReadLine();
}
static void Test3()
{
int[, ,] arr = { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 10 }, { 11, 12, 13 } } };
int[] i = { 1, 1, 1 };
Console.WriteLine(arr.GetValue(i));
}
