MATLAB y el algebra lineal

AYUDA EN LÍNEA

Matlab proporciona asistencia de varios modos.

Si queremos consultar un comando determinado podemos buscar información
escribiendo en la ventana de comandos help <comando a consultar>, o simplemente
help. También podemos abrir la ventana de ayuda con el ratón o con la tecla F1. Una
vez abierta esta ventana podemos buscar por contenidos, palabras concretas,
demostraciones…
Por último con la orden lookfor <palabra>, busca en todas las primeras líneas de las
ayudas de los temas de Matlab y devuelve aquellos que contienen la palabra clave que
hemos escrito. No es necesario que la palabra clave sea una orden de Matlab.

FUNCIONES MATEMÁTICAS COMUNES

APROXIMACIONES

(con x escalar, vector o matriz, pero redondearía en cada caso los elemento
individualmente)

Ejemplo:
>> round ( [19.54646 13.656 -2.1565 0.78] )
ans =
20 14 -2 1
TRIGONOMETRÍA

Ejemplos:
>> sin (pi/2)
ans =
1
>> sind (-90)
ans =
-1
>> cosd (60)
ans =
0.5000
>> asind (1)
ans =
90

ALGUNAS OPERACIONES

(x e y cualquier escalar, m y n enteros)

Ejemplos:
>> abs (-7) % valor absoluto de -7
ans =
7
>> sign (10) % signo del número 10
ans =
1
>> gcd (9,12) % máximo común divisor entre 9 y 12
ans =
3
>> lcm (10,25) % mínimo común múltiplo
ans =
50

>> mod (-12,5) % módulo de la división de -12 entre 5

ans =
3
> rem (12,5) % resto de la división de 12 entre 5
ans =
2

>> nthroot (8,3) % raíz cúbica de 8

ans =
2

VECTORES Y MATRICES

CÓMO DEFINIRLOS
Para crear un vector introducimos los valores deseados separados por espacios (o
comas) todo ello entre corchetes []. Si lo que queremos es crear una matriz lo hacemos
de forma análoga pero separando las filas con puntos y comas (;).
Generalmente usaremos letras mayúsculas cuando nombremos a las matrices y
minúsculas para vectores y escalares. Esto no es imprescindible y Matlab no lo exige,
pero resulta útil.
Ejemplos:

>> x = [5 7 -2 4 -6] % es un vector, los elementos los separamos con espacios

x=
5 7 -2 4 -6

>> y = [2,1,3,7] % es otro vector, los elementos los separamos con comas
y=
2137

>> z = [0 1 2,3 4,5] % es otro vector, da igual separar los elementos por comas o
espacios
z=
012345

>> A = [1 2 3; 4 5 6] % es una matriz con 2 filas y 3 columnas

A=
123
456

DIRECCIONAMIENTO DE ELEMETOS DE VECTORES Y

MATRICES

Para acceder a los elementos individuales de un vector lo haremos utilizando

subíndices, así x(n) sería el n-ésimo elemento del vector x. Si queremos acceder al
último podemos indicarlo usando end como subíndice.

>> x = [5 7 -2 4 -6];
>> x (2) % segundo elemento del vector x
ans =
7

>> x (end) % último elemento del vector x

ans =
-6

Para acceder a un bloque de elementos a la vez, se usa la notación de dos puntos (:), así
x (m:n) nos da todos los elementos desde el m-ésimo hasta el n-ésimo del vector x.

>> x (2:4) % devuelve desde el segundo al cuarto elemento del vector x

ans =
7 -2 4

Si introducimos un número entre el primero y el segundo también separado por dos

puntos (:) se mostrarán los elementos del primero al último indicado, incrementados
según el número que aparece en el centro (o decrementados si el número es negativo).

>> x (1:2:5) % devuelve el primero, tercero y quinto elemento del vector x

ans =
5 -2 -6

Otra forma de obtener un conjunto concreto de elementos del vector es indicando entre
corchetes [] las posiciones de los elementos que queremos obtener poniendo paréntesis
fuera de los corchetes.

>> x ( [3 5 1] ) % devuelve el tercer, quinto y primer elemento del vector x

ans =
-2 -6 5

Para acceder a los elementos de una matriz necesitamos dar dos valores, el primero
indica la fila y el segundo la columna.

>> A = [1 2 3; 4 5 6];
>> A (2,1) % elemento de la matriz que está en la fila 2 y en la columna 1
ans =
4

Si queremos que escriba toda una fila usaremos los dos puntos para indicar que
queremos todos los elementos.

>> A (2,:) % escribe la segunda fila de la matriz

ans =
456

Y similar si queremos que escriba toda una columna pero ahora situamos los dos puntos
en el lugar de las filas para indicar que queremos todas las filas de esa columna.

>> A (:,2) % escribe la segunda columna de la matriz

ans =
2
5
Al igual que con los vectores podemos indicar que escriba una serie de filas o columnas,
la manera de hacerlo sería muy parecido.

>> A (2,2:3) % escribe de la segunda fila de la matriz, las columnas de la 2 a la 3

ans =
56
>> A (2, [3 1] ) % escribe de la segunda fila de la matriz, las columnas 3 y 1
ans =
64
>> A ( [2 1] , 2:3) % escribe de las filas 2 y 1 de la matriz, las columnas de la 2 a la 3
ans =
56
23

>> A (end, [1 3] ) % escribe de la última fila, las columnas 1 y 3

ans =
46

Matlab tiene además otra forma de identificar cada elemento de una matriz, de modo
que podemos acceder a un elemento de una matriz indicando sólo un valor y no dos,
pero debemos saber que el orden elegido por Matlab es por columnas así los elementos
de la matriz A serían denominados:

Ejemplo:
Como la matriz A que teníamos era

A=
123
456

>> A (5) % accede al elemento 5 de la matriz, es decir, igual que si escribiéramos A

(1,3)
ans =
3

Pero es preferible para evitar confusiones trabajar con los elementos de las matrices
indicando la fila y la columna correspondiente.

CONSTRUCCIÓN ABREVIADA DE ALGUNOS VECTORES

A parte de definir un vector introduciendo cada uno de sus elementos, también podemos
crearlo haciendo uso de las siguientes sentencias:
(a:b) crea un vector que comienza en el valor a y acaba en el valor b aumentando de 1
en 1.
(a:c:b) crea un vector q comienza en el valor a y acaba en el valor b aumentando de c
en c.
linspace (a,b,c) genera un vector linealmente espaciado entre los valores a y b con c
elementos.
linspace (a,b) genera un vector linealmente espaciado entre los valores a y b con 100
elementos.
logspace (a,b,c) genera un vector logarítmicamente espaciado entre los valores 10^a y
10^b con c elementos.
logspace (a,b) genera un vector logarítmicamente espaciado entre los valores 10^a y
10^b con 50 elementos.

Ejemplos:
>> (1:7) % crea un vector que comienza en 1, aumenta de 1 en 1 y acaba en 7
ans =
1234567

>> (1:3:10) % crea un vector que comenzando en 1, aumenta de 3 en 3 hasta el 10

ans =
1 4 7 10

>> (1:4:10) % comenzando en 1, aumenta de 4 en 4 hasta el 10 y por eso acaba en 9

ans =
159

>> (50:-7:1) % crea un vector que comenzando en 50, disminuye de 7 en 7 hasta el 1

ans =
50 43 36 29 22 15 8 1

>> linspace (2,6,3) % genera un vector desde el 2 al 6 con 3 elementos equidistantes

ans =
246

>> linspace (2,6,4) % genera un vector desde el 2 al 6 con 4 elementos equidistantes

ans =
2.0000 3.3333 4.6667 6.0000

>> logspace (0,2,4) % genera un vector logarítmicamente espaciado entre 10^0 y 10^2
con 4 elementos
ans =
1.0000 4.6416 21.5443 100.0000

CONSTRUCCIÓN DE ALGUNAS MATRICES

Al igual que pasa con los vectores, existen unas sentencias que nos ayudan a crear más
rápidamente algunas matrices que Matlab ya tiene predefinidas (m y n deben tomar
valores naturales):
zeros (n) crea una matriz cuadrada n x n de ceros.
zeros (m,n) crea una matriz m x n de ceros.
ones (n) crea una matriz cuadrada n x n de unos.
ones (m,n) crea una matriz m x n de unos.
rand (n) crea una matriz cuadrada n x n de números aleatorios con distribución
uniforme (0,1).
rand (m,n) crea una matriz m x n de números aleatorios con distribución uniforme
(0,1).
randn (n) crea una matriz n x n de números aleatorios con distribución normal (0,1).
randn (m,n) crea una matriz m x n de números aleatorios con distribución normal (0,1).
eye (n) crea una matriz cuadrada n x n de unos en la diagonal y ceros el resto.
eye (m,n) crea una matriz m x n de unos en la diagonal y ceros el resto.
magic (n) crea una matriz cuadrada n x n de enteros de modo que sumen lo mismo las
filas y las columnas.
hilb (n) crea una matriz cuadrada n x n de Hilbert, es decir, los elementos (i,j)
responden a la expresión (1/(i+j-1)).
invhilb (n) crea una matriz cuadrada n x n que es la inversa de la matriz de Hilbert.
Ejemplos:

>> zeros (3) % matriz cuadrada 3 x 3 de ceros

ans =
000
000
000

>> zeros (2,5) % matriz 2 x 5 de ceros

ans =
00000
00000

>> ones (2,3) % matriz de unos

ans =
111
111

>> rand (2,4) % matriz de valores aleatorios entre 0 y 1 según la uniforme (0,1)
ans =
0.9355 0.4103 0.0579 0.8132
0.9169 0.8936 0.3529 0.0099

>> randn (2,5) % matriz de valores aleatorios según la normal (0,1)

ans =
0.8156 1.2902 1.1908 -0.0198 -1.6041
0.7119 0.6686 -1.2025 -0.1567 0.2573

>> eye (2) % matriz identidad o unidad

ans =
10
01
>> magic (4) % matriz mágica 4 x 4
ans =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> hilb (3) % matriz de Hilbert 3 x 3
ans =
1.0000 0.5000 0.3333
0.5000 0.3333 0.2500
0.3333 0.2500 0.2000

>> invhilb (3) % inversa de la matriz de Hilbert 3 x 3

ans =
9 -36 30
-36 192 -180
30 -180 180

OPERACIONES BÁSICAS CON MATRICES

Ejemplos:
Definimos tres matrices para poder hacer operaciones entre ellas.
A=B=C=
1 2 1 1 1.0000 + 1.0000i 2.0000 + 2.0000i
3 4 0 1 3.0000 + 1.0000i 4.0000 + 7.0000i

>> A * B % multiplicación de matrices

ans =
13
37

>> A .* B % multiplicación elemento a elemento

ans =
12
04

>> C ' % traspuesta conjugada

ans =
1.0000 - 1.0000i 3.0000 - 1.0000i
2.0000 - 2.0000i 4.0000 - 7.0000i

>> C .' % traspuesta

ans =
1.0000 + 1.0000i 3.0000 + 1.0000i
2.0000 + 2.0000i 4.0000 + 7.0000i

>> A + 2 % si sumamos el número 2 a la matriz se suma ese número a cada elemento

ans =
34
56

FUNCIONES PARA OPERAR CON VECTORES

Ejemplos:
>> x = [1 2 3]; y = [4 5 6];
>> cross (x,y) % producto vectorial
ans =
-3 6 –3

>> dot (x,y) % producto escalar

ans =
32
FUNCIONES PARA EL ANÁLISIS DE MATRICES

(Con A matriz, v vector y n número natural)

Ejemplos:
>> diag (v) % crea una matriz diagonal a partir del vector v
ans =
100
020
003

>> A = [1 2 3 4; 7 8 9 2; 2 4 6 8]
A=
1234
7892
2468

>> diag (A) % crea un vector columna a partir de la diagonal de la matriz A

ans =
1
8
6

>> size (A) % devuelve las dimensiones de la matriz como un vector fila
ans =
34
>> length (A) % devuelve la mayor de las dos dimensiones de la matriz
ans =
4

>> trace (A) % traza de la matriz

ans =
15

>> rank (A) % rango de la matriz

ans =
2

>> rref (A) % reducción mediante Gauss

ans =
1.0000 0 -1.0000 -4.6667
0 1.0000 2.0000 4.3333
0000

>> l = tril (A), u = triu (A)

l=
1 0 0 0 % convierte en ceros todos los elementos que quedan encima de
7 8 0 0 % la diagonal principal y lo guarda en la variable l
2460

u=
1 2 3 4 % convierte en ceros todos los elementos que quedan debajo de
0 8 9 2 % la diagonal principal y lo guarda en la variable u
0068

OTRAS OPERACIONES CON MATRICES

(Con A matriz, m y n naturales)

Ejemplos:
>> A = [pi 0; pi/4 pi/3]
A=
3.1416 0
0.7854 1.0472

>> find (A) % devuelve los índices como un vector columna

ans =
1
2
4

>> reshape (A,1,4)

ans =
3.1416 0.7854 0 1.0472

>> rot90 (A) % gira la matriz 90º

ans =
0 1.0472
3.1416 0.7854

>> rot90 (A,3) % gira la matriz 270º ( 90º x 3 = 270º )

ans =
0.7854 3.1416
1.0472 0

>> funm (A,@sin) % calcula el seno de cada elemento de la matriz

ans =
0.0000 0
-0.3248 0.8660
>> expm (A)
ans =
23.1407 0
7.6091 2.8497

TEXTO
Una cadena de caracteres es texto rodeado por comillas simples (') y se manejan como
vectores filas. Se direccionan y manipulan igual que los vectores. Son posibles las
operaciones matemáticas sobre cadenas. Una vez hecha una operación matemática sobre
una cadena, ésta se ve como un vector de números en ASCII.
Para ver la representación ASCII de una cadena, podemos utilizar las funciones abs,
double o sumamos cero. Para restaurarla y verla de nuevo como cadena de caracteres,
usamos la función setstr. Si queremos cambiar a minúsculas añadiremos la diferencia
entre 'a' y 'A'.
Si queremos que escriba algo en pantalla podemos utilizar el comando disp.

Ejemplos:
>> a = 'casa'; b = 'gato'; % a y b son cadenas de caracteres (se manejarán como vectores)
>> a + b
ans =
202 194 231 208

>> a + 0 % vemos la representación ASCII de la cadena

ans =
99 97 115 97

>> abs (a) % otra forma de ver la representación ASCII de la cadena

ans =
99 97 115 97

>> double (a) % otra tercera forma de ver la representación ASCII de la cadena
ans =
99 97 115 97

>> setstr (ans) % convertimos un vector de número enteros en caracteres

ans =
casa

>> abs ('a') – abs ('A') % calculamos la diferencia entre minúsculas y mayúsculas
ans =
32
>> setstr (a-32) % escribimos los caracteres conociendo la representación ASCII
ans =
CASA

>> disp (a) % escribe el valor almacenado en la variable a

casa
>> disp ('escribe esto') % escribe el texto que vaya entre las comillas
escribe esto

HIPERMATRICES
CÓMO DEFINIRLAS

Matlab permite trabajar con matrices de más de dos dimensiones. Los elementos de una
hipermatriz pueden ser números, caracteres, estructuras y vectores o matrices de celdas.
Las funciones que operan con matrices de más de dos dimensiones son análogas a las
funciones vistas anteriormente aunque con algunas diferencias, por ejemplo, a la hora de
definirlas:

>> HM(:,:,1) = [1 2 3; 4 5 6]; % definimos la primera capa

>> HM(:,:,2) = [7 8 9; 10 11 12] % definimos la segunda capa

HM(:,:,1) =
123
456

HM(:,:,2) =
789
10 11 12

OPERACIONES CON HIPERMATRICES

Algunas funciones para generar matrices admiten más de dos subíndices y pueden ser
utilizadas para generar hipermatrices como rand, randn, zeros y ones, también se
pueden emplear con hipermatrices las funciones size y reshape entre otras. La función
cat permite concatenar matrices según las distintas “dimensiones”.

Ejemplos:
>> A = zeros (2,3); B = ones (2,3); % definimos dos matrices de las mismas
dimensiones

>> cat (1,A,B) % las concatena una debajo de la otra

ans =
000
000
111
111

>> cat (2,A,B) % las concatena una al lado de la otra

ans =
000111
000111

>> cat (3,A,B) % las concatena como distintas capas de una hipermatriz
ans(:,:,1) =
000
000

ans(:,:,2) =
111
111

Respecto al resto de funciones debemos tener en cuenta que:

1. Las funciones que operan sobre escalares, como sin, cos, etc., se aplican sobre
hipermatrices elemento a elemento (igual que ocurre al aplicarlas sobre vectores
y matrices).
2. Las funciones que operan sobre vectores, como sum, max, etc., se aplican a
matrices e hipermatrices según la primera dimensión, resultando un array de una
dimensión inferior.
3. Las funciones matriciales propias del álgebra lineal, como det, inv, etc., no se
pueden aplicar a hipermatrices, para aplicarlas habría que extraer las matrices
correspondientes.

ESTRUCTURAS
CÓMO DEFINIRLAS

Es una agrupación de datos de tipo diferente bajo un mismo nombre. A los datos les
llamamos campos. No hace falta definir previamente el modelo de la estructura,
podemos ir creando los distintos campos uno a uno o bien con el comando struct, donde
los nombres de los campos se escriben entre apóstrofos (') seguidos del valor que se les
quiere asignar.

Ejemplos:
>> alumno.nombre = 'Pablo'; % introducimos el campo nombre en la estructura alumno
>> alumno.apellido1 = 'Fernández'; % introducimos el campo apellido1 en la estructura
alumno
>> alumno.apellido2 = 'García'; % introducimos el campo apellido2 en la estructura
alumno
>> alumno.edad = 15; % introducimos el campo edad en la estructura alumno
>> alumno % escribe por pantalla la información almacenada en la estructura alumno
alumno =
nombre: 'Pablo'
apellido1: 'Fernández'
apellido2: 'García'
edad: 15
>> alumno2 = struct ('nombre','Fermín','apellido1','Martínez','apellido2','Gil','edad',16)
alumno2 = % otro modo de introducir los campos
nombre: 'Fermín'
apellido1: 'Martínez'
apellido2: 'Gil'
edad: 16

Pueden crearse vectores y matrices de estructuras, por ejemplo:

>> alumno (1) = struct
('nombre','Pablo','apellido1','fernández','apellido2','García','edad',15);
>> alumno (2) = struct
('nombre','Fermín','apellido1','Martínez','apellido2','Gil','edad',16);
>> alumno % nos devuelve información sobre los campos que tiene la estructura
alumno
alumno =
1x2 struct array with fields:
nombre
apellido1
apellido2
edad

>> alumno (1) % nos devuelve los datos del primer elemento del vector de la estructura
ans =
nombre: 'Pablo'
apellido1: 'fernández'
apellido2: 'García'
edad: 15

>> alumno (2) % nos devuelve los datos del segundo elemento del vector de la
estructura
ans =
nombre: 'Fermín'
apellido1: 'Martínez'
apellido2: 'Gil'
edad: 16

Para ver un campo concreto de todos los alumnos bastaría teclear:

>> alumno.nombre % escribe los datos de todos los campo nombre de la estructura en
orden
ans = Pablo
ans = Fermín

OPERAR CON ESTRUCTURAS

(E es una estructura y c es un campo)

Ejemplos:
>> fieldnames (alumno) % devuelve los campos de la estructura alumno
ans =
'nombre'
'apellido1'
'apellido2'
'edad'
>> isfield (alumno,'nombre') % devuelve 1 por ser cierto que nombre es un campo de
alumno
ans =
1
>> isstruct (alumno) % devuelve 1 porque es cierto que alumno es una estructura
ans =
1
>> rmfield (alumno,'edad') % elimina el campo edad de la estructura alumno
ans =
1x2 struct array with fields:
nombre
apellido1
apellido2

VECTORES Y MATRICES DE CELDAS

CÓMO DEFINIRLOS
Un vector de celdas es un vector cuyos elementos son cada uno de ellos una variable de
cualquier tipo. En todo vector sus elementos pueden ser números o cadenas de
caracteres, pero en un vector de celdas el primer elemento puede ser un número, el
segundo una matriz, el tercero una estructura, etc.

Para crear un vector de celdas usaremos llaves ({}).

>> celda (1) = {[0 1 2]}; % creamos un vector de celdas definiendo celda a celda
>> celda (2) = {'cadena de caracteres'};
>> celda (3) = {eye(2)};
>> celda (4) = {-7};
>> celda
celda =
[1x3 double] [1x20 char] [2x2 double] [-7]

>> cel {1} = [0 1 2]; % creamos otro vector de celdas definiendo celda a celda de forma
distinta
>> cel {2} = 'cadena de caracteres';
>> cel {3} = eye (2);
>> cel {4} = -7;
>> cel
cel = [1x3 double] [1x20 char] [2x2 double] [-7]
>> c = { [0 1 2] ,'cadena de caracteres',eye(2),-7}; % otra forma de crear un vector de
celdas. Si queremos crear una matriz o una hipermatriz de celdas se haría de forma
similar.

OPERAR CON VECTORES Y MATRICES DE CELDAS

(m y n números naturales, c celdas y x vector o matriz)

Ejemplos:
>> cell (2,3) % crea una matriz de celdas vacías
ans =
[] [] []
[] [] []

>> celldisp (c) % escribe el contenido de las celdas de c

c{1} =
012
c{2} =

cadena de caracteres
c{3} =
10
01
c{4} =
-7

>> cellplot (c) % representa gráficamente cómo son las celdas de c

>> iscell (c)

ans =
1
>> A = eye (3,2);
>> num2cell (A)
ans =
[1] [0]
[0] [1]
[0] [0]

OPERACIONES RELACIONALES Y LÓGICAS

Como entradas a las expresiones relacionales y lógicas, Matlab considera que cero es
falso y que cualquier número distinto de cero es verdadero. La salida de expresiones de
este tipo produce 1 si es verdadero y 0 si es falso.

OPERADORES RELACIONALES

La salida de las operaciones lógicas se puede utilizar también en operaciones

matemáticas.

OPERADORES LÓGICOS
Además de los operadores relacionales y lógicos básicos anteriores, Matlab proporciona
una serie de funciones relacionales y lógicas adicionales que incluyen:

Podemos ver muchos más casos pero todos serían similares: ischar, isempty, isequal,
isfloat, isinteger, islogical, isnumeric, isprime, isreal, isscalar, isspace, …
Existe un orden de precedencia para operadores aritméticos, lógicos y relacionales, en la
siguiente tabla van de mayor a menor precedencia:

Ejemplos:

>> a = 1:9, b = 5-a % definimos dos vectores

a=
123456789
b=
4 3 2 1 0 -1 -2 -3 -4
>> r1 = a<6 % pregunta si a es menor que 6, devuelve 1 cuando es verdadero y 0
cuando es falso
r1 =
111110000

>> r2 = a==b % pregunta si a es igual a b, devuelve 1 cuando es verdadero y 0 cuando

es falso
r2 =
000000000

>> r3 = a~=b % pregunta si a es distinto a b, devuelve 1 cuando es verdadero y 0

cuando es falso
r3 =
111111111

>> r4 = (a>b)&(b>-3) % pregunta si a>b y b>-3, devuelve 1 cuando es verdadero y 0

cuando es falso
r4 =
001111100

>> c = [Inf 0 5 -8 NaN 94];

>> exist ('c') % pregunta si existe alguna variable llamada c
ans =
1

>> isnan (c) % pregunta cuando c es NaN, devuelve 1 cuando es verdadero y 0 cuando
es falso
ans =
000010

>> isinf (c) % pregunta cuando c es Inf, devuelve 1 cuando es verdadero y 0 cuando es
falso
ans =
100000

>> isfinite (c) % pregunta cuando c es finito, devuelve 1 cuando es verdadero y 0

cuando es falso
ans =
011101