Intentando convertir un int [] en int [,] usando C#

Question

Me gustaría una función para convertir una matriz de dimensión única int [480000] en una matriz 2d de tamaño int [800,600]. ¿Puede ayudarme por favor cómo se puede hacer esto?

Answer 1

public static T[,] Convert<T>(this T[] source, int rows, int columns) 
{ 
    int i = 0; 
    T[,] result = new T[rows, columns]; 

    for (int row = 0; row < rows; row++) 
    for (int col = 0; col < columns; col++) 
     result[row, col] = source[i++]; 
    return result; 
} 

Answer 2

for (int i = 0; i < 800; ++i) { 
    for (int j = 0; j < 600; ++j) { 
     m[i, j] = a[600*i + j]; 
    } 
} 

Dependiendo de su diseño de almacenamiento, puede que tenga que usar i + 800*j en su lugar.

Answer 3

UPD (llenado fijado por columna en lugar de por fila, aquí es la versión correcta)

private static T[,] create2DimArray<T>(T[] array, int n) 
     { 
      if (n <= 0) 
       throw new ArgumentException("Array M dimension cannot be less or equals zero","m"); 
      if (array == null) 
       throw new ArgumentNullException("array", "Array cannot be null"); 
      if (array.Length == 0) 
       throw new ArgumentException("Array cannot be empty", "array"); 

      int m = array.Length % n == 0 ? array.Length/n : array.Length/n + 1; 
      var newArr = new T[m,n]; 
      for (int i = 0; i < arr.Length; i++) 
      { 
       int k = i/n; 
       int l = i % n; 
       newArr[k, l] = array[i]; 
      } 

      return newArr; 
     } 

Por 1.000.000 de elementos funciona 33 ms en mi máquina. Muy rápido con 1 for loop.

Answer 4

¿Realmente desea mover físicamente los datos o sería suficiente una "Vista" de 800x600?
Se puede usar un envoltorio de esta manera:

// error checking omitted 
class MatrixWrapper<T> 
{ 
    private T[] _data; 
    private int _columns; 

    public MatrixWrapper(T[] data, int rows, int columns) 
    { 
     _data = data; 
     _columns = columns; 
     // validate rows * columns == length 
    } 

    public T this[int r, int c] 
    { 
     get { return _data[Index(r, c)]; } 
     set { _data[Index(r, c)] = value; } 
    } 

    private int Index(int r, int c) 
    { 
     return r * _columns + c; 
    } 
} 

Y usarlo como:

 double[] data = new double[4800]; 
     var wrapper = new MatrixWrapper<double>(data, 80, 60); 
     wrapper[2, 2] = 2.0;