Replicando le matrici verso l'esterno da un punto centrale

Question

Sono abbastanza nuovo nella programmazione, quindi sto cercando alcuni esperti per spingermi nella giusta direzione mentre completo questo esercizio.

Ho usato Horzcat e Vertcat per farlo manualmente, ma sto chiedendo se qualcuno conosce un modo più semplice.

Matrix 1 è 18x18 e indicizzato in orizzontale a partire da 1.

Matrix 1 è al centro e rappresenta uno spazio discreto. Matrix 2,3,3,4,5,6,7,8,9 sono replicati di Matrix 1, rappresentano anche spazi discreti e si trovano a destra, in basso a destra, in basso a sinistra, a sinistra, in alto a sinistra, sopra e in alto a destra.

Matrix 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 sono anche replicati di Matrix One e surround Matrix 2 a 9. Le matrici costruite insieme uno schema come sotto. Ogni matrice è essa stessa un'unità discreta.

Se si definisce il numero di matrici richieste, quindi diciamo in questo caso "49" o "4 passi da Matrix 1" (una persona può saltare da 1, 9, 25, 49 su una diagonale o 1, 8, 23, 46 su una linea retta), come posso costruire le matrici in questo schema?

                      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     

Se dimostro questo diagrammaticamente, spero di poter esprimere meglio il mio problema.

Quindi il primo anello è questo:

                               7 8 9
                               6 1 2
                               5 4 3

Il secondo anello è questo:

                       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

Il terzo anello è

                  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

e così via. Vorrei poter continuare questo modello all'infinito.

Qual è il modo migliore per farlo in Matlab?

Mi scuso per la mia mancanza di chiarezza e ho bisogno di esprimere meglio il mio problema. Tutti i tuoi commenti sono molto utili per mostrarmi come scrivere un problema adeguato.

Molte grazie per il tuo aiuto. Appena unito a questo forum poiché il supporto qui è eccezionale.

Answer 1

Se tutte le tue matrici sono veramente copie ("replicate") di quella iniziale (chiamalo mat18), per il tuo nIl passo che potresti semplicemente chiamare

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

per esempio

largemat=repmat(mat18, 7,7);

Per produrre la matrice che hai descritto nel tuo esempio. Come dice Clement, questo crea direttamente la grande matrice, non espandendo una esistente.

Aggiornamento 2

Se le tue matrici sono diverse, ad esempio, hai 49 matrici memorizzate in a array di cellule mymatrices{1}, mymatrices{2}, ... mymatrices{49}, inizieresti

largemat{1}=mymatrices{1};

Ora per calcolare il prossimo largemat{n+1} da mymatrices e largemat{n}, devi aggiungere i prossimi mymatry "intorno" al largemat{n}. largemat{n} Contiene già il primo m^2 matrici con m=2*n+1, quindi avrai bisogno mymatrices{(m^2+1):((m+2)^2)} e disporre correttamente:

e poi in ogni passaggio ingrandiscilo

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

Per testare questo codice, usiamo numeri semplici per i tuoi sottomissioni:

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

Ora possiamo eseguire il codice sopra in un ciclo, stampare risultati intermedi per verificare:

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

che stampe

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

Per verificarlo funziona anche per le matrici di ingresso non scalari, l'uso

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

come input, il che non si schianta ... anche se non ho verificato manualmente che la matrice risultante è corretta ;-).

Answer 2

Probabilmente è più semplice scrivere una funzione che genera tutta la tua matrice per un determinato numero di livelli invece di provare ad espandere una matrice esistente con un nuovo livello.