Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Arreglos multidimensionales

Un arreglo multidimensional en MATLAB® es un arreglo con más de dos dimensiones. En una matriz, las dos dimensiones se representan con filas y columnas.

Cada elemento se define mediante dos subíndices, el índice de la fila y el índice de la columna. Los arreglos multidimensionales son una ampliación de las matrices de dos dimensiones y utilizan subíndices adicionales para la indexación. Un arreglo 3D, por ejemplo, utiliza tres subíndices. Los dos primeros son como una matriz, pero la tercera dimensión representa páginas u hojas de elementos.

Crear arreglos multidimensionales

Puede crear un arreglo multidimensional creando una matriz de dos dimensiones en primer lugar y, después, ampliándola. Por ejemplo, defina primero una matriz de 3 por 3 como la primera página de un arreglo 3D.

A = [1 2 3; 4 5 6; 7 8 9]
A = 3×3

     1     2     3
     4     5     6
     7     8     9

Ahora, añada una segunda página. Para ello, asigne otra matriz de 3 por 3 al valor 2 del índice de la tercera dimensión. La sintaxis A(:,:,2) utiliza dos puntos en las dimensiones primera y segunda para incluir todas las filas y las columnas que quedan a la derecha de la asignación.

A(:,:,2) = [10 11 12; 13 14 15; 16 17 18]
A = 
A(:,:,1) =

     1     2     3
     4     5     6
     7     8     9


A(:,:,2) =

    10    11    12
    13    14    15
    16    17    18

La función cat puede resultar una herramienta útil para crear arreglos multidimensionales. Por ejemplo, cree un nuevo arreglo 3D B concatenando A con una tercera página. El primer argumento indica qué dimensión concatenar.

B = cat(3,A,[3 2 1; 0 9 8; 5 3 7])
B = 
B(:,:,1) =

     1     2     3
     4     5     6
     7     8     9


B(:,:,2) =

    10    11    12
    13    14    15
    16    17    18


B(:,:,3) =

     3     2     1
     0     9     8
     5     3     7

Otra forma de ampliar rápidamente un arreglo multidimensional es asignar un único elemento a toda una página. Por ejemplo, añada una cuarta página a B que contenga todo ceros.

B(:,:,4) = 0
B = 
B(:,:,1) =

     1     2     3
     4     5     6
     7     8     9


B(:,:,2) =

    10    11    12
    13    14    15
    16    17    18


B(:,:,3) =

     3     2     1
     0     9     8
     5     3     7


B(:,:,4) =

     0     0     0
     0     0     0
     0     0     0

Acceder a los elementos

Para acceder a los elementos de un arreglo multidimensional, utilice subíndices enteros como lo haría con los vectores y las matrices. Por ejemplo, busque el elemento 1,2,2 de A, que se encuentra en la primera fila, la segunda columna y la segunda página de A.

A
A = 
A(:,:,1) =

     1     2     3
     4     5     6
     7     8     9


A(:,:,2) =

    10    11    12
    13    14    15
    16    17    18

elA = A(1,2,2)
elA = 11

Utilice el vector índice [1 3] en la segunda dimensión para acceder solo a las columnas primera y última de cada página de A.

C = A(:,[1 3],:)
C = 
C(:,:,1) =

     1     3
     4     6
     7     9


C(:,:,2) =

    10    12
    13    15
    16    18

Para buscar las filas segunda y tercera de cada página, utilice el operador de dos puntos para crear su vector índice.

D = A(2:3,:,:)
D = 
D(:,:,1) =

     4     5     6
     7     8     9


D(:,:,2) =

    13    14    15
    16    17    18

Manipular arreglos

Los elementos de los arreglos multidimensionales se pueden mover de muchas maneras, al igual que los vectores y las matrices. reshape, permute y squeeze son funciones útiles para reorganizar elementos. Considere un arreglo 3D con dos páginas.

Remodelar un arreglo multidimensional puede resultar útil para llevar a cabo determinadas operaciones o visualizar los datos. Utilice la función reshape para reorganizar los elementos del arreglo 3D en una matriz de 6 por 5.

A = [1 2 3 4 5; 9 0 6 3 7; 8 1 5 0 2];
A(:,:,2) = [9 7 8 5 2; 3 5 8 5 1; 6 9 4 3 3];
B = reshape(A,[6 5])
B = 6×5

     1     3     5     7     5
     9     6     7     5     5
     8     5     2     9     3
     2     4     9     8     2
     0     3     3     8     1
     1     0     6     4     3

reshape actúa en las columnas, creando la nueva matriz tomando los elementos consecutivos de cada columna de A de forma descendente, comenzando por la primera página y pasando, después, a la segunda.

Las permutaciones se utilizan para reorganizar el orden de las dimensiones de un arreglo. Considere un arreglo 3D M.

M(:,:,1) = [1 2 3; 4 5 6; 7 8 9];
M(:,:,2) = [0 5 4; 2 7 6; 9 3 1]
M = 
M(:,:,1) =

     1     2     3
     4     5     6
     7     8     9


M(:,:,2) =

     0     5     4
     2     7     6
     9     3     1

Utilice la función permute para intercambiar los subíndices de las filas y las columnas de cada página especificando el orden de las dimensiones en el segundo argumento. Las filas originales de M son ahora columnas y las columnas son ahora filas.

P1 = permute(M,[2 1 3])
P1 = 
P1(:,:,1) =

     1     4     7
     2     5     8
     3     6     9


P1(:,:,2) =

     0     2     9
     5     7     3
     4     6     1

De manera similar, intercambie los subíndices de las filas y las páginas de M.

P2 = permute(M,[3 2 1])
P2 = 
P2(:,:,1) =

     1     2     3
     0     5     4


P2(:,:,2) =

     4     5     6
     2     7     6


P2(:,:,3) =

     7     8     9
     9     3     1

Al trabajar con arreglos multidimensionales, podría encontrarse con uno que tuviera una dimensión innecesaria de longitud 1. La función squeeze realiza otro tipo de manipulación que elimina las dimensiones de longitud 1. Por ejemplo, utilice la función repmat para crear un arreglo de 2 por 3 por 1 por 4 cuyos elementos sean todos 5 y cuya tercera dimensión tenga una longitud de 1.

A = repmat(5,[2 3 1 4])
A = 
A(:,:,1,1) =

     5     5     5
     5     5     5


A(:,:,1,2) =

     5     5     5
     5     5     5


A(:,:,1,3) =

     5     5     5
     5     5     5


A(:,:,1,4) =

     5     5     5
     5     5     5

szA = size(A)
szA = 1×4

     2     3     1     4

numdimsA = ndims(A)
numdimsA = 4

Utilice la función squeeze para eliminar la tercera dimensión, lo que da lugar a un arreglo 3D.

B = squeeze(A)
B = 
B(:,:,1) =

     5     5     5
     5     5     5


B(:,:,2) =

     5     5     5
     5     5     5


B(:,:,3) =

     5     5     5
     5     5     5


B(:,:,4) =

     5     5     5
     5     5     5

szB = size(B)
szB = 1×3

     2     3     4

numdimsB = ndims(B)
numdimsB = 3

Temas relacionados