Converting a 2D Array of 2D Arrays into a single 2D Array

arrays, c#, matrix, multidimensional-array

Solution

I started with a simple Matrix class to hold the `double[,]`s. Nothing too fancy, just a simple array-of-arrays with a row and column count and array accessor.

class Matrix<T>
{
    public int Rows { get; private set; }
    public int Cols { get; private set; }

    private T[,] mat;

    public Matrix(int rowCount, int colCount)
    {
        Rows = rowCount;
        Cols = colCount;
        mat = new T[Rows, Cols];
    }

    public T this[int r, int c]
    {
        get { return mat[r, c]; }
        set { mat[r, c] = value; }
    }
}

Your second case looks more difficult (and like a better test of correctness) than the first, so I set up a metamatrix to match that.

public static Matrix<double[,]> BuildMetaMatrix()
{
    Matrix<double[,]> m = new Matrix<double[,]>(2, 2);

    m[0, 0] = new double[,]
    {
        { 1 }
    };

    m[0, 1] = new double[,]
    {
        { 3, 3, 3 },
        { 3, 3, 3 },
        { 3, 3, 3 }
    };

    m[1, 0] = new double[,]
    {
        { 2, 2 },
        { 2, 2 }
    };

    m[1, 1] = new double[,]
    {
        {4, 4, 4, 4},
        {4, 4, 4, 4},
        {4, 4, 4, 4},
        {4, 4, 4, 4}
    };

    return m;
}

For convenience, I made a Place function that puts one matrix into another one at the given location.

static void Place(double[,] src, double[,] dest, int destR, int destC)
{
    for (int row = 0; row < src.GetLength(ROW_DIM); row++)
    {
        for (int col = 0; col < src.GetLength(COL_DIM); col++)
        {
            dest[row + destR, col + destC] = src[row, col];
        }
    }
}

The magic numbers fed into `GetLength()` were just asking for mistakes, so I defined some constants for them (`ROW_DIM = 0` and `COL_DIM = 1`). I decided to handle the padding by figuring out how wide a column is and how tall a row is and skipping any extra elements after `Place()`ing the sub-matrix in. A `GetRowHeight()` and `GetColWidth()` method figure out the values.

public static int GetRowHeight(Matrix<double[,]> m, int row)
{
    int maxSeen = 0;

    for (int col = 0; col < m.Cols; col++)
    {
        if (m[row, col].GetLength(ROW_DIM) > maxSeen)
        {
            maxSeen = m[row, col].GetLength(ROW_DIM);
        }
    }

    return maxSeen;
}

public static int GetColWidth(Matrix<double[,]> m, int col)
{
    int maxSeen = 0;

    for (int row = 0; row < m.Rows; row++)
    {
        if (m[row, col].GetLength(COL_DIM) > maxSeen)
        {
            maxSeen = m[row, col].GetLength(COL_DIM);
        }
    }

    return maxSeen;
}

A `Flatten()` function loops through all the sub-matrices, `Place()`ing them at the appropriate row and column in a new matrix. It updates the next row and column after each `Place()` using the `GetRowHeight()` and `GetColWidth()` functions.

Matrix<double> Flatten(Matrix<Matrix<double>> src)
{
    // (7, 6) == (this.TotalRows(), this.TotalColumns())
    // from your code.
    Matrix<double> dest = new Matrix<double>(7, 6);

    int nextRow = 0;
    int nextCol = 0;

    for (int row = 0; row < src.Rows; row++)
    {
        for (int col = 0; col < src.Rows; col++)
        {
            dest.Place(src[row, col], nextRow, nextCol);
            nextCol += GetColWidth(src, col);
        }
        nextRow += GetRowHeight(src, row);
        nextCol = 0;
    }

    return dest;
}

A little glue to test it out...

static void Main(string[] args)
{
    Matrix<double[,]> src = BuildMetaMatrix();
    double[,] dest = Flatten(src);

    Print(dest);
    Console.ReadLine();
}

static void Print(double[,] matrix)
{
    for (int row = 0; row < matrix.GetLength(ROW_DIM); row++)
    {
        for (int col = 0; col < matrix.GetLength(COL_DIM); col++)
        {
            Console.Write(matrix[row, col] + "\t");
        }
        Console.Write("\n");
    }
}

...and you get an output just like your second case with all the oddly fitting matrices and `0`s in the empty places.*

1       0       3       3       3       0
0       0       3       3       3       0
0       0       3       3       3       0
2       2       4       4       4       4
2       2       4       4       4       4
0       0       4       4       4       4
0       0       4       4       4       4

*The destination matrix gets its values initialized to `default(double)`, which happens to be `0` (the value you wanted). If you need something other than `default(double)` for the empty places, you can probably get them by iterating over the new matrix and writing the new default value everywhere before `Flatten()`ing the metamatrix.

(Thanks to Jeff Mercado for pointing out that multidimensional arrays' `GetLength()` method can be used to find their dimensions.)

Problem

Original source