Replicando matrices hacia afuera desde un punto central

Question

Soy bastante nuevo en la programación, así que estoy buscando algunos expertos que me empujen en la dirección correcta a medida que completa este ejercicio.

He usado Horzcat y Vertcat para hacer esto manualmente, pero pregunto si alguien sabe una manera más simple.

La matriz 1 es 18x18 e indexada horizontalmente a partir de 1.

Matrix 1 está en el centro y representa un espacio discreto. La matriz 2,3,4,5,6,7,8,9 son réplicas de la Matriz 1, también representan espacios discretos y se encuentran a la derecha, inferior a la derecha, debajo, abajo a la izquierda, a la izquierda, a la parte superior izquierda, arriba y arriba a la derecha.

Matrix 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 también son réplicas de Matrix One y Surround Matrix 2 a 9. Las matrices construidas juntas se forman un patrón como se muestra a continuación. Cada matriz es en sí misma una unidad discreta.

Si define el número de matrices que necesita, así que digamos en este caso '49' o '4 pasos de la matriz 1' (una persona puede saltar de 1, 9, 25, 49 en una diagonal o 1, 8, 23, 46 en línea recta), ¿cómo construyo las matrices en este patrón?

                      43  44  45  46 47  48 49
                      42  21  22  23 24  25 26
                      41  20  7   8   9  10 27
                      40  19  6   1   2  11 28
                      39  18  5   4   3  12 29
                      38  17  16  15  14 13 30
                      37  36  35  34  33 32 31     

Si demuestro esto diagramáticamente, espero poder expresar mi problema mejor.

Entonces el primer anillo es este:

                               7 8 9
                               6 1 2
                               5 4 3

El segundo anillo es este:

                       21  22  23  24  25
                       20  7   8   9   10
                       19  6   1   2   11
                       18  5   4   3   12
                       17  16  15  14  13

El tercer anillo es

                  43  44  45  46  47  48  49
                  42  21  22  23  24  25  26
                  41  20   7   8   9  10  27
                  40  19   6   1   2  11  28
                  39  18   5   4   3  12  29
                  38  17  16  15  14  13  30
                  37  36  35  34  33  32  31

y así. Me gustaría poder continuar este patrón infinitamente.

¿Cuál es la mejor manera de hacer esto en Matlab?

Pido disculpas por mi falta de claridad y necesito expresar mejor mi problema. Todos sus comentarios son muy útiles para mostrarme cómo escribir un problema adecuado.

Muchas gracias por tu ayuda chicos. Acabo de unir este foro ya que el soporte aquí es excepcional.

Answer 1

Si todas sus matrices son realmente copias ("replicas") de la inicial (llámalo mat18), para tu nel paso al que podrías llamar

largemat=repmat(mat18, 2*n+1, 2*n+1);

p.ej

largemat=repmat(mat18, 7,7);

Para producir la matriz que describió en su ejemplo. Como dice Clement, esto crea la gran matriz directamente, no expandiendo una existente.

Actualización 2

Si tus matrices son diferentes, por ejemplo, tiene 49 matrices almacenadas en un matriz celular mymatrices{1}, mymatrices{2}, ... mymatrices{49}, comenzarías por

largemat{1}=mymatrices{1};

Ahora para calcular el siguiente largemat{n+1} de mymatrices y largemat{n}, necesitas agregar las próximas mymatrices "alrededor" de los largemat{n}. largemat{n} ya contiene el primero m^2 matrices con m=2*n+1, entonces necesitarás mymatrices{(m^2+1):((m+2)^2)} y organizarlos correctamente:

y luego en cada paso agriarlo

largemat{n+1} = [ largemat{n} cell2mat(mymatrices(m^2+(1:m))')]; %# add to the right
largemat{n+1} = [ largemat{n+1} ; cell2mat(mymatrices(m^2+m+(m+1:-1:1)))]; %# add at bottom
largemat{n+1} = [ cell2mat(mymatrices(m^2+2*m+1+(m+1:-1:1))') largemat{n+1}]; %# add at right
largemat{n+1} = [ cell2mat(mymatrices(m^2+3*m+2+(1:m+2))) ; largemat{n+1}]; %# add at top

Para probar este código, usemos números simples para sus submatrices:

mymatrices=mat2cell(1:49,1,ones(1,49));

Ahora podemos ejecutar el código anterior en un bucle, imprimiendo resultados intermedios para verificar:

largemat{1}=mymatrices{1};
for n=1:3
    m=2*n-1;
    largemat{n+1} = [ largemat{n} cell2mat(mymatrices(m^2+(1:m))')]; %# add to the right
    largemat{n+1} = [ largemat{n+1} ; cell2mat(mymatrices(m^2+m+(m+1:-1:1)))]; %# add at bottom
    largemat{n+1} = [ cell2mat(mymatrices(m^2+2*m+1+(m+1:-1:1))') largemat{n+1}]; %# add at right
    largemat{n+1} = [ cell2mat(mymatrices(m^2+3*m+2+(1:m+2))) ; largemat{n+1}]; %# add at top
    largemat{n+1}
end

que imprime

ans =
     7     8     9
     6     1     2
     5     4     3
ans =
    21    22    23    24    25
    20     7     8     9    10
    19     6     1     2    11
    18     5     4     3    12
    17    16    15    14    13
ans =
    43    44    45    46    47    48    49
    42    21    22    23    24    25    26
    41    20     7     8     9    10    27
    40    19     6     1     2    11    28
    39    18     5     4     3    12    29
    38    17    16    15    14    13    30
    37    36    35    34    33    32    31

Para probarlo también funciona para matrices de entrada nocalar, usar

mymatrices=cell(1,49);
for i=1:49,mymatrices{i}=rand(9,9),end;

como entrada, que no se bloquea ... aunque no he verificado manualmente que la matriz resultante es correcta ;-).

Answer 2

Probablemente sea más simple escribir una función que genere toda su matriz para un número determinado de capas en lugar de tratar de expandir una matriz existente con una nueva capa.