具有非零下限的二维数组的子数组

Question

The extension :

public static T[,] SubArray<T>(this T[,] values, int row_min, int row_max, int col_min, int col_max)
{
    int num_rows = row_max - row_min + 1;
    int num_cols = col_max - col_min + 1;
    T[,] result = new T[num_rows, num_cols];

    int total_cols = values.GetUpperBound(1) + 1;
    int from_index = row_min * total_cols + col_min;
    int to_index = 0;
    for (int row = 0; row <= num_rows - 1; row++)
    {
        Array.Copy(values, from_index, result, to_index, num_cols);
        from_index += total_cols;
        to_index += num_cols;
    }

    return result;
}

work well for 2D arrays arrays whose GetLowerBound(0) and GetLowerBound(1) are equal to zero. For instance if

int[,] arr1 = new int[5, 4];
for (int i = 0; i < 5; ++i)
{
    for (int j = 0; j < 4; ++j)
    {
        arr1[i, j] = i + j;
    }
}

var arr1sub = arr1.SubArray(2, 3, 1, 3);

Then arr1sub is the 2d array with 2 rows and 3 colums (boths with indexes starting at 0)

3  4  5
5  6  7

Now if I look at the case where the initial array as indexes not starting at zero :

int[,] arr2 = (int[,])Array.CreateInstance(typeof(int), new int[] { 5, 4 }, new int[] { 3, 1 });
for (int i = arr2.GetLowerBound(0); i <= arr2.GetUpperBound(0); ++i)
{
    for (int j = arr2.GetLowerBound(1); j <= arr2.GetUpperBound(1); ++j)
    {
        arr2[i, j] = i - arr2.GetLowerBound(0) + j - arr2.GetLowerBound(1);
    }
}
var arr2sub = arr2.SubArray(5, 6, 2, 4);

the last line of previous code snippet will trigger an exception in the SubArray extension function at the line

Array.Copy(values, from_index, result, to_index, num_cols);

for row equal to zero.

I understand of the 2d array arr1 (with zero based indexes) is layed out in memory but not how the 2d array arr2 (with non-zero-based indexes) is layed out in memory, hence my use of Array.Copy must be wrong in this case, but I don't see why.

Answer 1

You are not calculating total_cols and from_index correctly.

public static T[,] SubArray<T>(this T[,] values, int row_min, int row_max, int col_min, int col_max)
{
    int num_rows = row_max - row_min + 1;
    int num_cols = col_max - col_min + 1;
    T[,] result = new T[num_rows, num_cols];

    int total_cols = values.GetLength(1);
    int from_index = (row_min - values.GetLowerBound(0)) * total_cols + (col_min - values.GetLowerBound(1)) + values.GetLowerBound(0);
    int to_index = 0;
    for (int row = 0; row <= num_rows - 1; row++)
    {
        Array.Copy(values, from_index, result, to_index, num_cols);
        from_index += total_cols;
        to_index += num_cols;
    }

    return result;
}

total_cols is the obvious one; as for from_index , I cannot find any documentation on that, but it would appear that sourceIndex in Array.Copy starts counting from sourceArray.GetLowerBound(0) and not from zero, which is not necessarily immediately obvious given that this index keeps growing across rows and columns.