Replicando matrizes para fora de um ponto central

Question

Eu sou muito novo em programação, então estou procurando alguns especialistas para me orientar na direção certa enquanto eu concluo este exercício.

Usei horzcat e vertcat para fazer isso manualmente, mas estou perguntando se alguém conhece uma maneira mais simples.

Matriz 1 é 18x18 e indexada horizontalmente começando em 1.

A matriz 1 está no centro e representa um espaço discreto. As matrizes 2,3,4,5,6,7,8,9 são réplicas da matriz 1, também representam espaços discretos e estão localizadas à direita, inferior direita, inferior, inferior esquerda, esquerda, superior esquerda, superior e superior direita.

Matrix 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 também são réplicas da matriz um e envolvem a Matriz 2 a 9. As matrizes construídos juntos formam um padrão como abaixo. Cada matriz é em si uma unidade discreta.

Se você definir o número de matrizes de que necessita, digamos neste caso '49' ou '4 passos da matriz 1' (uma pessoa pode pular de 1, 9, 25, 49 em uma diagonal ou 1, 8 , 23,46 em uma linha reta), como faço para construir as matrizes neste padrão?

                      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 eu demonstrar isso de forma esquemática, espero poder expressar melhor meu problema.

Portanto, o primeiro toque é este:

                               7 8 9
                               6 1 2
                               5 4 3

o segundo toque é 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

o terceiro toque é

                  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 assim por diante. Eu gostaria de poder continuar com esse padrão infinitamente.

Qual é a melhor maneira de fazer isso no Matlab?

Peço desculpas por minha falta de clareza e preciso expressar melhor meu problema. Todos os seus comentários são muito úteis para me mostrar como escrever um problema adequado.

Muito obrigado pela ajuda, pessoal. Acabei de entrar neste fórum porque o suporte aqui é excepcional.

Answer 1

Se todas as suas matrizes são realmente cópias ("replicadas") da inicial (chame-o mat18), para o seu passo nth você pode simplesmente chamar

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

por exemplo,

largemat=repmat(mat18, 7,7);

para produzir a matriz que você descreveu em seu exemplo. Como Clemente diz, isso cria a grande matriz diretamente, não pela expansão de uma existente.

Atualização 2

Se suas matrizes forem diferentes , por exemplo, você tem 49 matrizes armazenadas em um array de células mymatrices{1}, mymatrices{2}, ... mymatrices{49}, você começaria por

largemat{1}=mymatrices{1};

Agora, para calcular o próximo largemat{n+1} de mymatrices e largemat{n}, você precisa adicionar as próximas mymatrices "ao redor" do largemat{n}. largemat{n} já contém as primeiras matrizes m^2 com m=2*n+1, portanto, você precisará de mymatrices{(m^2+1):((m+2)^2)} e organizá-las corretamente:

e, a cada passo, amplie-o

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 testar este código , vamos usar números simples para suas submatrizes:

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

Agora podemos executar o código acima em um loop, imprimindo resultados intermediários 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 testar também funciona com matrizes de entrada não-escalares, use

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

como entrada, que não trava ... embora eu não tenha verificado manualmente se a matriz resultante está correta ;-).

Answer 2

Provavelmente, é mais simples escrever uma função que gere toda a sua matriz para um determinado número de camadas em vez de tentar expandir uma matriz existente com uma nova camada.