Matrices

Matlab es un lenguaje de programación basado en matrices.

Una matriz es un arreglo bidireccional que contiene números reales o complejos. Una matriz de dimensión \(n \times m\) tiene \(n\) filas y \(m\) columnas.
Escalares en Matlab están representados por matrices \(1 \times 1\).
Vectores fila (columna) están representados por matrices \(n \times 1\) (\(1 \times n\)), con \(n\) el tamaño.

Existen dos formas de definir matrices: usando el teclado y/o leyendo archivos externos (de texto, excel, etc).

Usando el teclado: Toda matriz se inicia y termina con [ ], las columnas están separadas por espacios (o comas) y las columnas por punto y coma.
Leyendo archivos externos: Se usan los comandos textread, cvsread, xlsread, etc. Más adelante veremos detalles.

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

A =

     1     2     3
     4     5     6
     7     8     9

B = [1 2 3; 4 5 6]
C = [1; 2; 3]
D = [1 4 3]

B =

     1     2     3
     4     5     6


C =

     1
     2
     3


D =

     1     4     3

Secuencias

Es posible crear vectores a partir de secuencias con valores equidistantes unos de otros.

Forma 1: inicio:incremento:fin (incremento por defecto = 1). La secuencia termina en el número más cercano al número final definido.
Forma 2: linspace(inicio,fin,numero) (el incremento es calculado automáticamente).

Adicionalmente, existe la posibilidad de crear secuencias con número espaciados logarítmicamente.

Forma 3: logspace(inicio,fin,numero) crea un vector de numero elementos en el intervalo \([10^{inicio},10^{fin}]\) espaciados logarítmicamente.

H0 = (1:10)

H0 =

     1     2     3     4     5     6     7     8     9    10

H1 = 1:0.6:3

H1 =

    1.0000    1.6000    2.2000    2.8000

H2 = linspace(1,0.1,6)

H2 =

    1.0000    0.8200    0.6400    0.4600    0.2800    0.1000

H3 = logspace(1,3,3)

H3 =

          10         100        1000

Matrices Especiales

Matlab tiene funciones especialmente diseñadas para construir cierto tipo de matrices:

Matrices de ceros: zeros(nfilas,ncolumnas)
Matrices de unos: ones(nfilas,ncolumnas)
Matriz identidad: eye(dimesion)
Matrices con números aleatorios: rand(nfilas,ncolumnas) (uniforme \([0,1]\)) y randn(nfilas,ncolumnas) (Normal estándar).

ME1 = zeros(3,2)

ME2 = ones(4,1)

ME3 = eye(3)

ME3 =

     1     0     0
     0     1     0
     0     0     1

ME4 = rand(2,2)

ME4 =

    0.8147    0.1270
    0.9058    0.9134

ME5 = randn(3,1)

ME5 =

    0.3188
   -1.3077
   -0.4336

Notas: - Para generar número aleatorios de una distribución Normal con media \(\mu\) y desviación estándar \(\sigma\) usamos mu+sig*randn(nfilas,ncols). - Para generar número aleatorios de una distribución Uniforme definida en el intervalo \([a,b]\) usamos a+(b-a)rand(nfilas,ncols).

xn = 2+0.5*randn(3,3)
xu = 2+(4-2)*rand(2,2)

xn =

    2.1713    1.3251    1.9685
    3.7892    3.5175    2.3574
    3.3847    2.3627    1.8975


xu =

    2.8435    3.5844
    3.8315    3.9190

Referenciación y Submatrices

Los elementos se una matriz se pueden referenciar de diversas formas:

Usando matriz(i,j) donde i es la fila y j es la columna.

A =

     1     2     3
     4     5     6
     7     8     9

a22 = A(2,2)
a31 = A(3,1)

Usando matriz(ii:if,ji:jf) para extraer más de un elemento. ii e if corresponden a la fila inicial y la fila final (lo mismo aplica a ci y cf para las columnas). Este método se usa para extraer submatrices o particionar.

A([1 2],[1 2])

subA1 = A(1:2,1:2)
subA2 = A(2:3,1:3)

subA1 =

     1     2
     4     5


subA2 =

     4     5     6
     7     8     9

Usar únicamente : indica toda la fila o columna según corresponda. El término end indica el último elemento.

subA3 = A(2,:)
subA4 = A(:,2:3)
subA5 = A(2:end,3)

subA3 =

     4     5     6


subA4 =

     2     3
     5     6
     8     9


subA5 =

     6
     9

Note que al usar matriz(ii:if,ji:jf) no estamos haciendo otra cosa que definir un vector secuencia dentro la matriz. Por tanto es válido usar vectores para referenciar elementos (en secuencia o no).

B=rand(4,6)
Ind = 1:4
subB1 = B(Ind,5)
subB2 = B(1:4,5)

B =

    0.1712    0.0462    0.3171    0.3816    0.4898    0.7547
    0.7060    0.0971    0.9502    0.7655    0.4456    0.2760
    0.0318    0.8235    0.0344    0.7952    0.6463    0.6797
    0.2769    0.6948    0.4387    0.1869    0.7094    0.6551


Ind =

     1     2     3     4


subB1 =

    0.4898
    0.4456
    0.6463
    0.7094


subB2 =

    0.4898
    0.4456
    0.6463
    0.7094

Podemos usar la misma lógica para elegir elementos que no son contiguos:

Indc = [1 3 4]
Indf = [2 4]
subB3 = B(Indf,Indc)

Indc =

     1     3     4


Indf =

     2     4


subB3 =

    0.7060    0.9502    0.7655
    0.2769    0.4387    0.1869

Concatenar Matrices

Para concatenar matrices usamos los mismos procedimientos que para la definición de matrices usando el teclado, la única diferencia está en que los elementos son matrices.

La matriz se define en [].
Concatenar horizontalmente , o (espacio).
Concatenar verticalmente ;.

Nota: Ser cuidadoso con la conformabilidad de las matrices.

A = rand(3,2)
B = rand(2,2)

C = [A ; B]    % Concatenar verticalmente A y B
D = [A' B]     % Concatenar horizontalmente la traspuesta de A con B

A =

    0.1626    0.9597
    0.1190    0.3404
    0.4984    0.5853


B =

    0.2238    0.2551
    0.7513    0.5060


C =

    0.1626    0.9597
    0.1190    0.3404
    0.4984    0.5853
    0.2238    0.2551
    0.7513    0.5060


D =

    0.1626    0.1190    0.4984    0.2238    0.2551
    0.9597    0.3404    0.5853    0.7513    0.5060

Matrices de Mayor Dimensión

Matlab es capaz de manipular matrices de mayor dimensión (ejemplo 3D). Todas las reglas de creación, referenciación, partición y concatenación aplican.

Nota: Sólo operaciones elemento por elemento son utilizables con matrices de mayor dimensión.

A = rand(3,3,3)

A(:,:,1) =

    0.6991    0.5472    0.2575
    0.8909    0.1386    0.8407
    0.9593    0.1493    0.2543


A(:,:,2) =

    0.8143    0.3500    0.6160
    0.2435    0.1966    0.4733
    0.9293    0.2511    0.3517


A(:,:,3) =

    0.8308    0.9172    0.7537
    0.5853    0.2858    0.3804
    0.5497    0.7572    0.5678

La indexación sigue los mismos principios anteriores:

Asub = A(2,2,3)

Asub =

    0.2858