“Quien no se resuelve a cultivar el hábito de

pensar, se pierde el mayor placer de la vida”

Thomas A. Edison

Temas actuales de análisis de

datos con MatLab
ESQUEMA BÁSICO DEL PROCESAMIENTO DE DATOS
TÉCNICAS DE ANÁLISIS:
 Tema

RESUMEN BÁSICO DE MATLAB

Tema I.
Operaciones con vectores y matrices
 Sumario

2.1. Definición de matrices desde el teclado

2.2. Operaciones con matrices
2.3. Matrices predefinidas
2.4. Direccionamiento de matrices y vectores.
El operador (:) y la función (cat)
2.5. Operadores relacionales
2.6. Operadores lógicos
 Definición de un vector
Vector fila: elementos separados con comas (,) o con espacios:
Vector columna: elementos separados con punto y coma (;) :
Fila a columna y viceversa: con la transpuesta ( ´ )

Ejemplos a) desde línea de comandos, b) prog.:

Vector fila Vector columna

 El operador (:)
El operador (:) es utilizado para
especificar rangos, su forma de empleo
es muy simple y sus beneficios inmensos.
Forma de empleo:
<vector>=[val_ini : paso : val_fin];

Ejemplo:
 Definición de matrices
Las matrices se definen por filas, los
elementos de la fila se separan por espacios o
comas (,) mientras que las filas van separadas
por punto y coma (;)

Ejemplos: Se ve en pantalla:
A=[1,2,3; 4,5,6; 7,8,9]
ó
A=[1 2 3; 4 5 6; 7 8 9]
 Definición de matrices
Observación 1
Una vez definida la matriz esta pasa a su
espacio de trabajo (Workspace) y estará
disponible para realizar cualquier
operación.
Ejemplo:
 Definición de matrices
Observación 2
MatLab introduce por defecto una
variable llamada (ans) de “answer”
sobre la cual también se puede operar.

Ejemplo:
 Definición de matrices
Observación 3
En MatLab se permite la creación de
matrices vacías.

Ejemplo:
 ¿Cómo acceder a los valores?
Los elementos de una matriz se acceden
poniendo los 2 índices entre paréntesis
separados por coma (Ej. A(1,2)).
Ejemplo: A(1,2)
 ¿Cómo acceder a los valores?
Observación 1
Si estamos trabajando con vectores
bastaría colocar un solo índice.

Ejemplo:
 Operaciones

Operaciones con escalares: VECTORES:

A+B=[a1+b1 a2+b2 ... an+bn]
v+k adición o suma
v-k sustracción o resta A-B =[a1-b1 a2-b2 ... an-bn]
v*k multiplicación
v/k divide por k cada elemento
de v A .* B=[a1.b1 a2.b2 ... an.bn]
k./v divide k por cada elemento A y B deben ser horizontales o verticales.
de v
v.^k potenciación cada Si A=[fila] y B=[Columna]: Producto punto = A*B
componente de v esta
elevado a k
k.^v potenciación k elevado A./ B=[a1/b1 a2/b2 ... an/bn]
cada componente de v
A .^ n1=[a1^n1 a2^n1... an^n1 ]

MATRICES: sin el punto A*B A/ B A ^ n1

 Operaciones
Ejemplo:
 Matrices predefinidas
eye(n) Matriz unitaria (n x n)
zeros(n) Matriz de ceros (n x n)
zeros(n,m) Matriz de ceros (n x m)
ones(n) Matriz de unos (n x n)
ones(n,m) Matriz de unos (n x m)
rand(n) Matriz de números aleatorios entre 0 y 1 (n x n)
rand(n,m) Matriz de números aleatorios entre 0 y 1 (n x m)
linspace Genera un vector con n valores entre x1 y x2
(x1,x2,n) igualmente espaciados
matriz mágica (n x n): 1 hasta N^2 con sumas
magic(n)
iguales en filas, columnas y diagonales.
 Operaciones con matrices
Ejemplos:
 Operaciones con matrices
Ejemplos:
 El operador (:)

El operador (:) se muestra mucho más

potente cuando se trabaja con matrices.
 El operador (:)
Extracción de submatrices.
 El operador (:)
Extracción de una columna.
 El operador (:)
Extracción de una fila (end = última).
 El operador (:)
Eliminación de una columna.
 La función (cat)

La función (cat) se emplea para

concatenar matrices a lo largo de una
dimensión especificada.
Al igual que el operador (:) es de una
gran utilidad cuando se trabaja con
matrices.
 La función (cat)
Ejemplo (1: abajo; 2: a la derecha):

C
Operadores relacionales

< Menor que

<= Menor o igual a
> Mayor que
>= Mayor o igual a
== Igual a
~= Distinto de
Operadores lógicos

&& Conjunción
|| Disyunción
~ Negación
xor Disyunción exclusiva
 ECUACIONES LINEALES
Dado un sistema algebraico de ecuaciones lineales de la
forma Ax=B. Lo resolveremos por métodos clásicos y
con funciones propias de matlab

Comandos:

>>det(A) %determinante de una matriz cuadrada

>>inv(A) %inversa de una matriz cuadrada
Ecuaciones lineales________________________________

Ejemplos de resolución de un sistema Ax=B:

Ejemplo: Resolver el sistema:

X1+2 X2+3 X3 = 4
2X1+3 X2+4 X3 = 5
4X1+2 X2+5 X3 = 1
Ecuaciones lineales________________________________
Resolución: Regla de Cramer

Resolución:
A=[1 2 3;2 3 4;4 2 5]
B=[4;5;1];

D1=A;D1(:,1)=B
D2=A;D2(:,2)=B
D3=A;D3(:,3)=B
x=[det(D1);det(D2);det(D3)]/
det(A)
Ecuaciones lineales________________________________

La solución por Cramer es tediosa y poco eficaz.

Una primera posibilidad más cómoda.

Ainv=inv(A)

x=Ainv*B
Otra solución sería utilizar la división matricial
X=A\B

A\B, produce un resultado aunque la matriz no sea cuadrada y aunque no

sea invertible.
Por ejemplo si el sistema esta sobredeterminado (más ecuaciones que
incógnitas) se calcula la solución que minimiza la norma 2 de Ax-b
(solución de mínimos cuadrados)
Autovalores (o valores propios) de una matriz

p es un valor propio de la matriz cuadrada Anxn si

cumple con:
A.v=p.v

Autovectores (o vectores propios ) de una matriz:

Los vectores solución obtenidos al remplazar cada uno
de los valores propios en la ecuación.

Ejemplo: Hallar los valores y vectores propios asociados

a la matriz
El sistema tiene solución ssi:

Lo cual se cumple para: t = 4 y t= -1 ( valores propios)

Remplazando c/u de los valores propios y resolviendo la ecuación:

En matlab:

eig(A) (vector columna)

[V,D]=eig(A)

(Vectores propios)
 POLINOMIOS
Los polinomios se representan en matlab por un
vector fila de dimensión n+1 siendo n el grado del
polinomio.

Dado un polinomio
x3+2x
se representa por
>> pol1=[1 0 2 0]
para el cálculo de las raíces de un polinomio existe el
comando roots.
>>raices=roots(pol1) (da un vector columna,
aunque pol1 es un vector fila)
Polinomios______________________________________
Un polinomio puede ser reconstruido a partir de sus
raíces con el comando poly
>> p=poly(raices) (da un vector fila) **
en caso de que el argumento de poly fuera una matriz
obtendríamos como resultado el polinomio característico
de la matriz. Así mismo si queremos calcular los
autovalores de la matriz bastaría con calcular las raíces
del polinomio característico.
Ejemplo1:
pol2=[2 4 0 1]; % definición del polinomio 2x3+4x2+1
raices=roots(pol2) % cálculo de sus raíces
pol2_n=poly(raices) % reconstrucción del polinomio
real(pol2_n) % ¿qué pasó?
Ejemplo2:
A=[1 2 3 ; 2 3 4; 4 2 5]; p=poly(A) % pol. característico
roots(p) % autovalores de A
Polinomios______________________________________
Para calcular el valor de un polinomio p en un punto
dado x1 basta con utilizar el comando polyval
>>y=polyval(p,x1)
Ejemplo: Evaluar el polinomio x3-x2-x+1 en el punto 2
p=[1 –1 –1 1] % definición del polinomio x3-x2-x+1
polyval(p,2)
Ejemplo: Ahora evaluarlo en todo un rango de puntos
x=-2:0.1:2;
Y=polyval(p,x);
Para multiplicar y dividir polinomios tenemos los
comandos especiales conv(p1,p2) y deconv(p1,p2)
Ejemplo5:
p1=[1, -2, 1]; p2=[1,1]; p3=conv(p1,p2)
p4=deconv(p3,p2)
[p4,r]=deconv(p3,p2) % resto de la división
Polinomios______________________________________
Para conocer el resto de la división de polinomios basta con
poner
>>[p4,r] = deconv(p3,p2)
El comando residue, permite el cálculo del desarrollo en
suma de fracciones simples del cociente p1/p2.
p2 debe tener raíces reales
El formato del comando es: >>[r,p,k] =residue(p1,p2)
donde:
r= vector columna con los numeradores
p= vector columna con las raices del denominador
k= vector fila con los coeficientes del polinomio
independiente.
p1( x ) r (1) r (n )
   k(x)
p2( x ) x  p(1) x  p(n )
Polinomios______________________________________

>>[p1,p2]=residue(r,p,k) hace la operación inversa

Ejemplo6:
Descomponer en fracciones simples el cociente
x3  x2  1
p1=[1 1 0 1]
x 3  3x 2  4
p2=[1 –3 0 4]
[r,p,k]=residue(p1,p2)
rats(r)
x3  x2  1 35 13 1
3 2
  2
 1
x  3 x  4 9( x  2) 3( x  2) 9( x  1)
[pol1,pol2]=residue(r,p,k)
Polinomios______________________________________

Para calcular la derivada de un polinomio tenemos el

comando,
>>polyder(p)
Ejemplo7:
Dado el polinomio x3+6x2+1 su derivada es

p=[1, 6,0,1];
d=polyder(p) % es decir 3x2+12x
 Tiempo y esfuerzo de cálculo

En MatLab está abierta la posibilidad de

obtener los tiempos de cálculo de una
forma muy sencilla para el usuario,
siendo esto en muchas ocasiones de suma
importancia.

Para este fin se emplean las funciones:

cputime; etime y tic ops toc
 Tiempo y esfuerzo de cálculo
% help clock
% CLOCK Current date and time as date vector.
% CLOCK returns a six element date vector vector containing the
% current time and date in decimal form:
% CLOCK = [year month day hour minute seconds]

% The first five elements are integers. The seconds element

% is accurate to several digits beyond the decimal point.
 Tiempo y esfuerzo de cálculo

% help etime

% ETIME Elapsed time.

% ETIME(T1,T0) returns the time in seconds that has elapsed
% between vectors T1 and T0. The two vectors must be six
% elements long, in the format returned by CLOCK:

% T = [Year Month Day Hour Minute Second]

 Tiempo de cálculo (ejemplo)
Se desea resolver un sistema lineal arbitrario con
1000 Ecs. de la forma:
Ax=b  x=A-1b = A\b
>> n=1000;
>> A=rand(n);
>> b=rand(n,1);
>> x=zeros(n,1);

Tiempo transcurrido ??
 Tiempo y esfuerzo de cálculo
% EJEMPLO (CON ECO EN LOS CLOCK):
% EJEMPLO (SIN ECO EN LOS CLOCK):
...
n=1000;
%Tiempo de inicio:
A=rand(n);
tiempoIni=clock % SIN PUNTO Y COMA
b=rand(n,1);
%operación:
x=zeros(n,1);
x=A\b;
%Tiempo de fin:
%Tiempo de inicio:
tiempoFin=clock % SIN PUNTO Y COMA
tiempoIni=clock;
tiempo=etime(tiempoFin, tiempoIni)
%operación:
RESULTADO:
x=A\b;
tiempoIni =
%Tiempo de fin:
1.0e+003 *
tiempoFin=clock;
2.0060 0.0090 0.0290 0.0090 0.0270 0.0436
tiempoFin =
tiempo=etime(tiempoFin, tiempoIni)
1.0e+003 *
2.0060 0.0090 0.0290 0.0090 0.0270 0.0506
RESULTADO: tiempo = 5.2810
tiempo = 7
 Tiempo y esfuerzo de cálculo
OTRAS FUNCIONES SIMILARES:
n=1000;
A=rand(n);
b=rand(n,1);
x=zeros(n,1);
tiempoIni=clock; x=A\b;
tiempo=etime(clock, tiempoIni)
time=cputime; x=A\b; time=cputime-
time
tic; x=A\b; toc

RESULTADOS:
tiempo = 5.3130
time = 5.2350
elapsed_time = 5.2030
Curso Matlab 2002-03 enxamb. Nieves
Lorenzo

PROGRAMACIÓN
PROGRAMACIÓN________________________________

Comandos de entrada salida

input: nos permite introducir datos

variable=input(‘mensaje a pantalla’);

disp: muestra un texto por pantalla

disp(‘El algoritmo no ha convergido’)
PROGRAMACIÓN________________________________

Testear el número de argumentos

nargin devuelve el número de argumentos de entrada con

los que el usuario ha llamado a la función.

nargout devuelve el número de argumentos de salida con

los que el usuario ha llamado a la función.

nargchk chequea si el número de argumentos de entrada

calculados con nargin esta entre el valor máximo y mínimo
previsto, si no da error.
nargchk(mínimo,máximo,número_entrada)
PROGRAMACIÓN________________________________

Bucles. Bucles anidados

for k=n1:incre:n2
end

Con break se rompe la ejecución

Estructuras de control condicionadas

switch expresion
case expresion_0

if comandos_0 que deben ejecutarse

case expresion_1

elseif comandos_1 que deben ejecutarse

while
case expresion_2

else comandos_2 que deben ejecutarse

end
otherwise

end comandos escoba que deben ejecutarse

end
PROGRAMACIÓN________________________________

Programación de funciones

function arg_salida=nombre_funcion(arg_entrada)

El fichero se debe guardar con nombre_funcion.m

Para devolver el control al programa desde cualquier punto

de una función basta con escribir la sentencia return

Ejercicio
Utilizando estructuras de control construir una función que
nos calcule las raíces de una ecuación de segundo grado
ax2+bx+c=0
function raiz=sole2(a,b,c)
%raiz=sole2(a,b,c)
%solucion de la ecuacion de segundo grado
%ax^2+bx+c=0, a~=0
%
if (nargin ~=3)
error(‘El numero de argumentos de entrada debe ser 3’)
end
discri=b^2-4*a*c;
raiz=[];
if(discri==0)
raiz=-b/(2*a);
disp([‘Raiz doble=‘,num2str(raiz)])
return
elseif(discri>0)

raiz(1)=(-b+sqrt(discri))/(2*a);
raiz(2)=(-b-sqrt(discri))/(2*a);
disp([‘Raices reales simples=‘,num2str(raiz)])
return
else
raiz(1)=(-b+sqrt(-discri)*i)/(2*a);
raiz(2)=(-b-sqrt(-discri)*i)/(2*a);
disp([‘Raices complejas=‘,num2str(raiz)])
return
end

Ejemplos para utilizar esta función:

raiz=sole2(2,3,1);
raiz=sole2(1,0,1);