---------------

Libro PDF Introducción rápida a Matlab y Simulink para ciencia e ingeniería – Manuel Gil Rodríguez

 Introducción rápida a Matlab y Simulink para ciencia e ingeniería - Manuel Gil Rodríguez

Descargar Libro PDF Introducción rápida a Matlab y Simulink para ciencia e ingeniería – Manuel Gil Rodríguez  


1.1. INTRODUCCIÓN
MatLab, desde las primeras versiones dispuso de help y demo, para iniciación
rápida. La información suministrada a través de los menús de estas ayudas,
correspondientes a las últimas versiones, crecieron de forma exponencial,
siendo de utilidad práctica disponer de un libro resumen de MatLab, en
donde se encuentren los comandos de uso más frecuente, a la vez que se muestren
sus aplicaciones prácticas en ejercicios, desde lo más sencillo, hasta otros
de mayor complejidad.
Este Capítulo es adecuado para principiantes absolutos, y de afianzamiento
a los ya iniciados.
1.2. COMENZANDO
Al arrancar MatLab, presenta una pantalla dividida en varias ventanas,
configurables desde Desktop Layout del menu de View; en una de las ventanas
estará el cursor parpadeando a la derecha de «>>», es la ventana de comandos
desde donde se ejecutan los mismos, las otras son informativas:
>> 3 + 4
ans =
7
>> 3*5
ans =
15
>> 15/3
ans =
5
1
1
Primeros pasos en MatLab
>> 15\3
ans =
0.2000
>> 2ˆ3
ans =
8
>> sin(2*pi*30/360)
ans =
0.5000
2 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
Figura 1.1. Ventanas de MatLab.
1.3. ESPACIO DE TRABAJO
Los datos y variables usadas residen en el espacio de trabajo, workspace,
accesible desde la ventana de comandos. Para inspeccionar el contenido de este
espacio se utilizan los comandos who y whos.
Los archivos directamente accesibles desde el espacio de trabajo, se muestran
mediante what. En el siguiente ejemplo se muestran sus características:
>> t = linspace(1,10,4) % Crea un vector de 4 elementos desde
% 1 a 10.
t =
1 4 7 10
>> t = t(:) % Crear el vector t en columna.
t =
1
4
7
10
>> A = 2*t; B = 2;
>> who
Your variables are:
t A B
>> whos
Name Size Bytes Class
t 1 × 4 32 double array
A 1 × 4 32 double array
B 1 × l 8 double array
Grand total is 9 elements using 72 bytes
>> what
M-files in the current directory D:\MatLab\work
AjusNL Datos EcudifP
AjusN1Fun Ecudif Fun
MAT-files in the current directory D:\MatLab\work
Datos
MDL-files in the current directory D:\MatLab\work
Bcont Bfuntab BnoLineal Bseñsis
Bfuentes Bmat Bsalidas Ecu2
En el espacio de trabajo se crearon 3 variables, 2 de 4 elemenos, y una de 1
elemento, de modo que son 9 elementos a 8 bytes por elemento, lo que hace un
total de 72 bytes.
A partir de la versión 6, release 12, MatLab incorporó workspace, potenciando
la capacidad de whos.
1.4. VARIABLES
En MatLab no es necesario hacer declaraciones previas acerca de las variables.
El contenido de las variables de caracteres ha de ir delimitado por el
signo «’».
>> numero_de_visitantes = 25
numero_de_visitantes =
25
PRIMEROS PASOS EN MATLAB 3
De ese modo se crean variables numéricas, numero_de_visitantes,
que almacenan su valores en una matriz, en este caso la matriz es de 1 × 1, y su
valor es 25.
» size(numero_de_visitantes) % Dimensión de variables.
ans =
1 1
» Nombre=’Pepe’; % Variable de caracteres.
» size (Nombre)
ans =
1 4
Los nombres de las variables deben seguir estas reglas:
1. Se forman con las letras del abecedario, los dígitos 0 a 9 y el signo «_»,
distinguiéndose mayúsculas de minúsculas.
2. Los nombres de las variables han de comenzar por una letra y no deben
contener espacios en blanco.
3. Los nombres de las variables no pueden coincidir con los nombres de las
keywords, nombres reservados.
La lista de los nombres reservados se obtiene por medio de iskeyword:
» iskeyword
ans =
‘break’
‘case’
‘catch’
‘continue’
‘else’
‘elseif’
‘end’
‘for’
‘function’
‘global’
‘if’
‘otherwise’
‘persistent’
‘return’
‘swirch’
‘try’
‘while’
4 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
>> if = 5
??? if = 5
Error: Expected a variable, function, or constant, found”=”.
Los nombres de las variables pueden ser tan extensos como se quiera, pero
MatLab sólo reconoce los 31 primeros caracteres.
Las variables se eliminan del espacio de trabajo con el comando clear:
clear Elimina las variables del espacio de trabajo.
clear variables Es equivalente al comando anterior.
clear global Elimina las variables globales.
clear functions Elimina todas las funciones compiladas.
clear all Elimina todas las variables, globales y funciones.
clear pipo* Elimina las variables que empiezan por pipo.
MatLab suministra amplia información adicional mediante help clear.
1.5. FORMATO DE NÚMEROS
MatLab presenta los resultados numéricos en varios formatos, según se expresa
a continuación:
>> help format
FORMAT Set output format.
All computations in MATLAB are done in double precision.
FORMAT may be used to switch between different output
display formats as follows:
FORMAT Default. Same as SHORT.
FORMAT SHORT Scaled fixed point format with 5 digits.
FORMAT LONG Scaled fixed point format with 15 digits.
FORMAT SHORT E Floating point format with 5 digits.
FORMAT LONG E Floating point format with 15 digits.
FORMAT SHORT G Best of fixed or floating point format
with 5 digits.
FORMAT LONG G Best of fixed or floating point format
with 15 digits.
FORMAT HEX Hexadecimal format.
FORMAT + The symbols +, – and blank are printed
for
positive, negative and zero elements.
Imaginary parts are ignored.
FORMAT BANK Fixed format for dollars and cents.
FORMAT RAT Approximation by ratio of small integers.
Spacing:
FORMAT COMPACT Suppress extra line-feeds.
FORMAT LOOSE Puts the extra line-feeds back in.
PRIMEROS PASOS EN MATLAB 5
Al mostrar resultados numéricos, MatLab sigue estas dos reglas:
1. MatLab intenta mostrar números enteros. Si el entero es muy grande, se
presenta en formato exponencial, con 5 cifras significativas.
2. Los números con decimales se muestran con 4 o 5 cifras significativas.
Los números en valor absoluto menores de 0,01 y mayores de 1.000, se
muestran en formato exponencial.
A continuación se muestran ejemplos demostrativos de formatos numéricos:
>> sqrt(2)
ans =
1.4142
>> format long
>> sqrt(2)
ans =
1.41421356237310
>> format Long e
>> sqrt (2)
ans =
1.41421356237310e+00
>> format short
>> A= [10000 0.0001]
ans =
1. 0e+04 *
1.0000 0.0000
>> format short g
>> A
A =
10000 0.0001
>> format rat
>> A
A =
10000 1/10000
6 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
1.6. PROGRAMAS
MatLab acepta comandos directos, para inmediatamente producir el resultado
o ejecutar una serie de comandos almacenados en un archivo, con la extensión
«.m».
Un archivo.m, consiste en una secuencia de sentencias MatLab, posiblemente
incluyendo referencias a otros archivo.m, o recursivamente a sí mismo.
A estos archivos los llamamos programas MatLab, en inglés scripts. Las variables
de los programas se mantienen en el espacio de trabajo, pudiendo ser invocadas
en cualquier momento para ver su contenido.
En una sentencia, lo que sigue a % no se ejecuta, se considera un comentario.
Si se desea construir una tabla con inversos, cuadrados y raíces cuadradas
de 1 a 10, se edita un archivo, Numeros.m, con cualquier editor, tal como
el bloc de notas del sistema operativo, o con el editor propio de MatLab, según:
% —————-Numeros.m ———————————–
x=1:10; % Crea un vector de 1 a 10 de 1 en 1. Vector en línea.
x=x’; % Transposición. Vector en columna.
x=[x,1../x,x.ˆ2,sqrt(x)]; % Matriz de 4 columnas.
% ————————————————————
El programa se invoca ejecutando «Numeros». Como en el programa todas
las sentencias se finalizaron con «;», no se muestra ningún valor numérico. Al
ejecutar «x», se obtendrá la tabla desada:
>> Numeros
>> x
x =
1.0000 1.0000 1.0000 1.0000
2.0000 0.5000 4.0000 1.4142
3.0000 0.3333 9.0000 1.7321
4.0000 0.2500 16.0000 2.0000
5.0000 0.2000 25.0000 2.2361
6.0000 0.1667 36.0000 2.4495
7.0000 0.1429 49.0000 2.6458
8.0000 0.1250 64.0000 2.8284
9.0000 0.1111 81.0000 3.0000
10.0000 0.1000 100.0000 3.1623
Pulsando la tecla ↑, se consiguen las líneas de los comandos previamente
ejecutadas.
PRIMEROS PASOS EN MATLAB 7
1.7. FUNCIONES
El otro tipo de archivos utilizado por MatLab son las funciones, cuya primera
característica es que sus variables son locales en su entorno y no definidas
en el espacio de trabajo, ni en otras funciones.
Buena parte de la potencia de MatLab se basa en su extenso conjunto de
funciones, las básicas y las distribuidas de forma separada para aplicaciones específicas,
MatLab toolboxes, y otras que desarrollan los usuarios.
Las funciones toman unas variables de entrada para calcular unos datos de
salida, sea:
almacenado en el archivo «Fun.m», cuyo contenido es:
function y=Fun(x)
% —————–Fun.m ————–
% Esto es un ejemplo
% de una función.
y=1../((x–1).ˆ2+0.1)+1../((x–3).ˆ2+0.2)–5;
%————————————-
Para evaluar Fun gráficamente, se lanza con las siguientes instrucciones:
>> x=–2:0.01:6; % Vector de –2 a 6, a incrementos de 0,01.
>> y=Fun(x); % Guardando el vector Fun(x) en y.
>> plot(x,y),grid % Representación con rejilla.
En Fun(x), x es el argumento o entrada de Fun, para dar unos resultados
de salida que se almacenan en y, que se muestran gráficamente.
Hay funciones del sistema o construidas por un usuario, que toman diferente
número de argumentos de entrada que de salida. Así la función max, toma un
vector de argumentos y puede suministrar una o dos salidas, según se use:
>> A = [1 2 1 5 2 3];
>> max(A) % Suministrará el valor máximo de A.
ans =
5
>> [X, i] = max(A) % X, valor máximo, i posición del máximo.
X =
5
i =
4
Fun x
x x
( )
( ) , ( ) ,
=
− +
+
− +
− 1
1 01
1
3 02 5 2 2
8 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
1.7.1. Reglas de construcción de funciones
1. El nombre de la función y del archivo deben ser idénticos.
2. Los nombres de las funciones se rigen por las normas de los nombres de
las variables.
3. La primera línea ejecutable de una función debe ser la línea de declaración
de función.
4. Las variables del interior de las funciones son variables locales.
5. El conjunto de líneas consecutivas de comentarios que siguen a function,
componen el texto de ayuda de esa función, obtenible mediante
help y lookfor.
>> help Fun
—————-Fun.m ————-
Esto es un ejemplo
de una función.
6. Una función termina al encontrar un retun o al llegar a la última línea
de la función.
7. Si una función llama a un programa, éste es evaluado en el espacio de
trabajo de la función y no en el workspace de MatLab.
8. Cada función tiene su espacio de trabajo separado del de MatLab, de
modo que la conexión entre estos ambientes se realiza a través de las variables
de entrada y salida de la función.
PRIMEROS PASOS EN MATLAB 9
–2 –1 0 1 2 3 4 5 6
–6
–4
–2
0
2
4
Figura 1.2. Representación gráfica de Fun.
9. Para compartir variables del interior de las funciones y del espacio de
trabajo, se declaran variables globales donde se necesiten mediante la
instrucción global.
>> global X a b % Declaración de variables globales
Para facilitar el manejo de funciones, MatLab incorporó recientemente @, y
feval, para mejorar eval, cuya utilidad se expone en el siguiente ejemplo:
>> F = @Fun % Creación directa de F.
F =
@Fun
>> feval(F,2)
ans =
-3.2576
Se consigue el mismo resultado con:
>> eval(‘Fun(2)’)
ans =
-3.2576
>> Fun(2)
ans =
-3.2576
>> F(2)=@cos % Creación directa de F(2).
F =
@Fun @cos
La eficiencia de feval es considerablemente superior a eval, ya que el
primero evalúa directamente lo que se invoca, mientras que eval llama al interpretador
completo de MatLab. La diferencia en tiempo de ejecución de ambas
funciones se pone de manifiesto con:
>> tic, for i = 1:100000, a = eval(‘Fun(i)’); end, toc
elapsed_time =
14.3210
>> tic, for i = 1:100000, a = feval(‘Fun’,i); end, toc
elapsed_time =
4.0960
10 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
1.7.2. Funciones en línea
Un segundo modo de definir funciones, sin editar archivos, se logra con
inline:
>> syms x y
>> f = inline(‘x.ˆ2 + y.ˆ2′)
f =
Inline function:
f(x) = x.ˆ2 + y.ˆ2
>> f(3,4)
ans =
25
>> feval(f,3,4)
ans =
25
1.7.3. Ejemplo de función recursiva
En muchas aplicaciones se presenta la recursividad, función que en su interior
se llama a sí misma. El ejemplo más secillo de recursividad es el cálculo
del factorial de un número:
N! = N × (N – 1)!
definiendo 1! como 1.
La función Factorial.m, toma un número de entrada, y suministra como salida
su factorial:
function f = Factorial(N)
% Esta función calcula el factorial de la parte
% entera de un número.
n = fix(N); % n toma la parte entera de N.
if n > 1
f = n*Factorial(n – 1);
else
f = 1;
end
Esta sencilla función toma un número y calcula el factorial de su parte
entera.
>> Factorial(3.3)
ans =
6
PRIMEROS PASOS EN MATLAB 11
1.8. NÚMEROS COMPLEJOS
MatLab admite operaciones con números complejos, permitiendo usar indistintamente
la i y la j, según se muestra en lo siguiente:
>> a = sqrt(–1)
a =
0 + 1. 0000i
>> conj(a)
ans =
0 – 1.0000i
>> sqrt(a)
ans =
0.7071 +0.7071i
>> exp(2i)
ans =
-0.4161 + 0.9093i
>> A = (3 + 4i)*(2 – j)
A =
10. 0000 + 5.0000i
>> r = real(A)
r =
10
>> I = imag(A)
I =
5
>> r = abs(A)
r =
11.1803
>> Angulo = angle(A)
12 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
Angulo =
0.4636
>> Angulo = atan2(imag(A),real(A))
0.4636
>> Aa = r*exp(Angulo*i)
Aa =
10.0000 + 5.0000i
1.9. MANEJO DE VECTORES Y MATRICES
La forma más sencilla de crear un vector es mediante el uso de [], vector
en línea, o con []’, vector en columna. Los elementos se separan por espacios
o comas, el «;» se reserva para anexar en columna:
>> t = [3 5 7, 8, 9]
t =
3 5 7 8 9
También se generan vectores mediante las instrucciones linspace y
logspace, ambos con dos o tres argumentos, y con «:», ya mencionado:
>> x = logspace(0,2,5) % Vector de 5 componentes de 10ˆ0 a
10ˆ2.
x =
1.000 3.1623 10.0000 31.6228 100.000
Con el siguiente ejemplo se muestra la creación y manejo de matrices:
>> x = 0:4
x =
0 1 2 3 4
>> y = x.ˆ2 % El punto antes del exponente
% hace que la exponenciación
y = % sea elemento a elemento.
0 1 4 9 16
>> a = [x;y] % Crear una matriz anexando
% vectores.
PRIMEROS PASOS EN MATLAB 13
a =
0 1 2 3 4
0 1 4 9 16
>> A = a’ % Crear la matriz A, transpues-
% ta de a.
A =
0 0
1 1
2 4
3 9
4 16
» B = [A; 5 25] % Añadir una línea a una ma-
% triz.
B =
0 0
1 1
2 4
3 9
4 16
5 25
>> C = reshape(B,3,4) % Reconfigurar la matriz B
% con 3 líneas y 4 columnas.
C =
0 3 0 9
1 4 1 16
2 25 4 50
>> C(2,:)=[] % Eliminar la 2a línea. Los
% dos puntos indican para
C = % todos los valores de esa
% dimensión.
0 3 0 9
2 25 4 50
>> C(:,3) = [] % Eliminar la 3a columna,
% 0 4.
C =
0 3 9
2 25 50
>> A = [1 2; 3 5]
A =
1 2
3 5
14 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
>> Aˆ2 % Diferencia entre ˆ y .ˆ
ans =
7 12
18 31
>> A.ˆ2
ans =
1 4
9 25
>> 1../A
ans =
1.0000 0.5000
0.3333 0.2000
>> det(A)
ans =
-1
>> inv(A)
ans =
-5.0000 2.0000
3.0000 -1.0000
Las exponenciaciones, elemento a elemento y matricial, también se realizan
con los comandos power y mpower, según:
>> x =[2 3 4];
>> y = power(x,2) % Equivalente a y = x.ˆ2
y =
4 9 16
>> x = [2 3;1 4];
>> y = mpower(x,2) % Equivalente a y = xˆ2
y
7 18
6 19
PRIMEROS PASOS EN MATLAB 15
1. 10. POLINOMIOS
Sea el polinomio p = x2 – 5x + 6, con vector de coeficientes C:
>> C = [1 -5 6];
Las raíces de este polinomio se obtienen, mediante:
>> r = roots(C)
r =
3
2
poly sobre las raíces devuelve los coeficientes del polinomio:
>> poly(r)
ans =
1 -5 6
polyval evalúa el polinomio sobre un valor:
>> polyval(C,5)
ans =
6
1.10.1. Multiplicación y división de polinomios
La multiplicación de dos polinomios, Pol1 = x2 + 2x + 3 por Pol2 = x – 1,
se efectúa por medio de conv:
>> Pol1 = [1 2 3];
>> Pol2 = [1 -1];
>> PolProd = conv(Pol1,Pol2)
PolProd =
1 1 1 -3
Cuyo resultado equivale a x3 + x2 + x – 3.
La división de polinomios se realiza mediante deconv:
>> PolDiv = deconv(PolProd,Pol2)
PolDiv =
1 2 3
16 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
1.10.2. Desarrollo en fracciones simples
Mediante residue, aplicado a dos polinomios, se obtienen fracciones
simples, cuya suma es equivalente al cociente de los polinomios:
>> P1 = [5 -20 9];
>> P2 = [1 -5 4];
>> [r,s,t] = residue(Pl,P2)
r =
3
2
s =
4
1
t =
5
Representando r, un vector columna con los numeradores de las fracciones,
s las raíces de cada denominador, y t los coeficientes del término independiente:
Si se conocen los numeradores, las raíces de los denominadores y los términos
independientes, se pueden generar los polinomios:
>> [p1,p2] = residue(r,s,t)
p1 =
5 -20 9
p2 =
1 -5 4
Siendo p1 y p2, los polinomios obtenidos, con los numeradores, raíces y
términos independientes.
1.10.3. Derivadas de polinomios
Las derivadas de los polinomios se obtienen con polyder:
>> derp1 = polyder(p1)
derp1 =
10 – 20
es decir, 10x – 20
5 20 9
5 4
3
4
2
1
5
2
2
x x
x x x x
− +
− +
=

+

+
PRIMEROS PASOS EN MATLAB 17
1.10.4. Integración de polinomios
La integral de un polinomio se obtiene mediante polyint(p), o con
polyint(p,C); en el primer caso se supone que la constante de integración
es 0, y en el segundo C:
>> polyint(p2)
ans =
0.3333 -2.5000 4.0000 0
>> polyint(p2,2)
ans =
0.3333 -2.5000 4.0000 2.0000
Equivalente a:
1.10.5. Interpolación polinomial
Matlab permite varios modos de interpolación, relacionados y descritos
en help interp1; a continuación se muestran unos ejemplos:
>> x = [2 4 6];
>> y = power(x,2); % Por defecto se utiliza el método
de
>> y5 = interp1(x,y,5) % interpolación lineal.
y5 =
26
>> y5c = interp1(x,y,5,’cubic’) % Interpolación cúbica.
y5c =
24.8750
>> y5s = interp1(x,y,5,’spline’)
y5s =
25
1
3
5
2
x3 − x3 + 4x + 2
18 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
1.11. matlabpath
El path de MatLab, llamado matlabpath, establece el camino para
buscar variables, programas y funciones de MatLab que sean llamados directamente
desde la ventana de comandos, o durante la ejecución de programas.
Al invocar un comando, MatLab lo busca, y ejecuta el que primero coincida
con el nombre invocado, según el siguiente orden:
1. Si es una variable del workspace.
2. Si es una función incorporada.
3. Si es un archivo.m presente en el directorio actual.
4. Lo busca siguiendo el orden establecido en matlabpath.
El comando which, aplicado sobre una función muestra su ruta:
>> which Fun
d:/MatLab6p5/work/Fun.m
1. 12. lookfor
lookfor aplicado a una variable de caracteres, busca esos caracteres en la
primera línea de comentarios de los archivo.m encontrados en el matlabpath.
>> lookfor Fun.m
Fun.m: %—————- Fun.m ——————–
1.13. LATEX
La función latex(A) devuelve la representación LATEX de una expresión
simbólica:
>> syms x
>> A = taylor(exp(–x))
A =
1 – x + 1/2*xˆ2 – 1/6*xˆ3 + 1/24*xˆ4 – 1/120*xˆ5
>> pretty(A)
2 3 4 5
1 – x + 1/2 x – 1/6 x + 1/24 x – 1/120 x
>> latex(A)
ans =
1 – x + 1/2\,{x}ˆ{2}-1/6\,{x}ˆ{3}+1/24\,{x}ˆ{4}-
{\frac{1}{120}}\,
{X}^{5}
PRIMEROS PASOS EN MATLAB 19
1.14. FUNCIONES DEL TIEMPO
MatLab suministra datos relacionados con el tiempo, como una variable de
caracteres, 12-Oct-1498, como una variable numérica, 739476 o como
un vector, 1789 07 14 0 0 0.
La función clock responde con:
>> Tiempo = clock
Tiempo =
1.0*e + 03 *
2.0030 0.0010 0.0290 0.0160 0.0400 0.0502
Esos datos responden a Tiempo[año mes día hora minutos segundos].
now devuelve la fecha y hora en un número, datestr convierte una fecha
numérica en string, datevec individualiza los componentes de fecha y hora,
datenum convierte una fecha en un número:
>> now
ans =
7.3161e + 05
>> datestr(7.3161e + 05)
29-Jan-2003
>> datevec(7.3161e + 05)
2003 1 29 0 0 0
>> datenum(date)
7.3161e + 05
La función date devuelve una variable de caracteres en el formato ddmmm-
yyyy:
>> date
ans =
29-Jan-2003
Numerosas transformaciones de fechas pueden encontrarse mediante help
datestr.
20 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
Para temporizaciones se usan tic, para comienzo, y toc para finalizar la
temporización y mostrar el resultado:
>> T = clock; tic, for i = 1:1000000, a = sqrt(i); end, …
toc, Tt = etime(clock,T)
elapsed_time =
3.6174
Tt =
3.6642
Los tres puntos seguidos indican continuación en la siguiente línea.
La ejecución de las raíces cuadradas de 1 a 1 millón, en un Pentium III a
866 Mhz, con Linux Suse 8.2 y Student MatLab 12, tarda 3.62 segundos.
La función etime devuelve el tiempo, en segundos, transcurrido entre
dos valores del tiempo:
>> etime(Tiempo,clock)
ans =
-1.2835e + 03
1.15. INTERCAMBIO DE DATOS
A partir de la versión 6, taınbién numerada como 12, MatLab presenta
una ventana de Historia de Comandos, en donde se listan las órdenes efectuadas,
de modo que en una sesión nueva se pueden buscar comandos ejecutados
en sesiones precedentes.
Para guardar el espacio de trabajo en un archivo, para posteriormente recuperarlo,
se utilizan los comandos load y save, según:
>> clear
>> X=rand(2,3)
X =
0.3046 0.1934 0.3028
0.1897 0.6822 0.5417
>> Y=round(X)
Y =
0 0 0
0 1 1
PRIMEROS PASOS EN MATLAB 21
>> save mi_archivo
>> clear
>> who
>>
>> load mi_archivo
>> who
Your variables are:
X Y
>> X
X =
0.3046 0.1934 0.3028
0.1897 0.6822 0.5417
>> Y
Y =
0 0 0
0 1 1
round se relaciona con ceil y floor, cuyas funciones se intuyen por su
significado:
>> A=[1.5 2.49; 0.2 9.99]
A =
1.5 2.49
0.2 9.99
>> ceil(A)
ans =
2 3
1 10
>> floor(A)
ans =
1 2
0 9
save y load permiten salvar o cargar variables determinadas, separadas
por espacios, a la vez que admiten el formato ASCII, añadiendo al final de estos
comandos -ascii, como se especifica en el siguiente ejemplo:
>> save exp_mayo.dat X -ascii
22 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
En el archivo exp_mayo.dat, se guarda la variable X en formato ASCII.
Para guardar la sesión de trabajo, se utiliza el comando diary, que almacena
una copia de todas las entradas realizadas desde el teclaclo en un archivo,
en el directorio actual, en formato ASCII:
PRIMEROS PASOS EN MATLAB 23

2.1. INTRODUCCIÓN
MatLab se caracterizó desde un principio por ser muy potente en cálculo
numérico, mientras que el cálculo simbólico fue incorporado como una toolbox,
cuando MathWorks, empresa que comercializa MatLab, se extendió internacionalmente.
La Symbolic Math Toolbox es una colección de herramientas para MatLab,
que se utilizan para manejar y resolver expresiones simbólicas.
Las herramientas simbólicas disponibles más usadas son; combinar, simplificar,
factorizar, derivar, integrar, límites, resolución de sistemas de ecuaciones
algebraicas o diferenciales, transformaciones integrales, la mayoría de
las operaciones del álgebra lineal…
Estas herramientas de cálculo simbólico son parte del programa Maple V,
comercializado por Waterloo Maple Software Inc.
2.2. OBJETOS Y EXPRESIONES SIMBÓLICAS
En Matlab hay dos tipos de objetos, numéricos y literales, strings. La Symbolic
Math Toolbox usa objetos simbólicos para representar variables y operadores,
por ejemplo:
>> x=sym(‘x’)
x =
x
25
2
Cálculo simbólico
Un objeto numérico puede convertirse en simbólico según:
>> M=magic(2) % M, variable numérica.
M =
1 3
4 2
>> N=sym(M) % N, variable simbólica.
N =
[1, 3]
[4, 2]
>> syms a b c d % Definición de simbólicos.
>> Mat=[a,b;c,d]
Mat =
[a, b]
[c, d]
>> det(Mat) % Cálculo del determinante.
ans =
a*d-b*c
>> M=(a-b)/(c+d)
M =
(a-b)/(c+d)
>> pretty(M)
a – b
c + d
Para la simplificación y transformaciones de expresiones se utilizan los operadores
collect, expand, horner, factor, simple y simplify, algunos
de los cuales se aplican en lo que sigue.
26 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
–3 –2 –1 0 1 2 3
–10
0
10
20
30
40
50
60
70
80
t
2 151/2 /5 sin(151/2 /2 t) exp(–3/2 t)
Figura 2.1. Representación gráfica de y.
2.3. EJEMPLOS DE CÁLCULO SIMBÓLICO
2.3.1. Derivadas e integrales
Se crea la función y, dependiente de t, según:
>> t=sym(‘t’);
>> y=sym(‘2*15^(1/2)/5*sin(15^(1/2)/2*t)*e^(-3/2*t)’);
>> pretty (y)
1/2 1/2 (- 3/2 t)
2/5 15 sin(1/2 15 t) e
La representación gráfica de y, para valores de -π a π, se consigue con la
instrucción:
>> ezplot(y,[-pi pi])
La derivada y’, almacenada en dy, simplificada y factorizada se obtiene según:
>> y
Y=
2*15^(1/2)/5*sin(15^(1/2)/2*t)*exp(-3/2*t)
>> dy=diff(y);
>> dy=simplify(dy);
>> dy=factor(dy);
>> pretty(dy)
1/2 1/2 1/2
– 3/5 exp(-3/2 t) (-5 cos(1/2 15 t)+15 sin(1/2 15 t))
La representación gráfica de dy se obtiene, como en el caso anterior, mediante
ezplot.
La integral de la derivada es la propia función, por lo tanto, integrando dy,
ha de obtenerse una expresión idéntica a la de y:
>> ezplot(dy, [-pi pi])
>> Intdy=int(dy,t);
>> Intdy=simplify(Intdy)
Intdy =
2/5*15^(1/2)*sin(1/2*15^(1/2)*t)*exp(-3/2*t)
CÁLCULO SIMBÓLICO 27
2.3.2. Sistemas de ecuaciones
Los sistemas de ecuaciones se resuelven mediante la instrucción solve, tomando
como argumentos el primer miembro de las ecuaciones igualadas a 0,
según:
x + y= 5
x – y= –1
ez·x = 7,389
>> syms x y z
>> [x,y,z]=solve(x+y-5,x-y+1,exp(x*z)-7.389)
x =
2
y =
3
z =
1/2*log(7389/1000)
>> z=double(z)
z =
1.0000
Si las ecuaciones a resolver no tienen solución analítica, solve devuelve
una expresión numérica, que se ejecuta mediante double, transformación a
doble precisión.
28 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
–3 –2 –1 0 1 2 3
–100
–80
–60
–40
–20
0
20
40
60
t
3/5 exp(3/2 t) (- 5 cos(1/2 151/2 t)+151/2 sin(1/2 151/2 t))
Figura 2.2. Representación gráfica de dy.
2.3.3. Ecuaciones diferenciales
La función dsolve calcula las soluciones simbólicas de ecuaciones diferenciales
ordinarias. Los argumentos de dsolve deben ser expresiones de caracteres,
strings, conteniendo el signo «=». Para indicar la derivada primera se
utiliza el signo D. para la derivada segunda se utiliza D2, y así sucesivamente.
La sintaxis de esta operación se expresa como:
r=dsolve(‘Ecu1,Ecu2,…’,’Cond1,Cond2,…’,’x’)
siendo x la variable independiente; si no se expresa se utiliza t por defecto.
Obteniendo y”, por derivación de y’, se puede componer con y e y’, la siguiente
ecuación diferencial:
La solución a esta ecuación diferencial se obtiene según:
>> yc=dsolve(‘D2y+3*Dy+6*y=0,Dy(0)=3,y(0)=0’)
yc =
2/5*15^(1/2)*exp(-3/2*t)*sin(1/2*15^(1/2)*t)
La especificación de las constantes iniciales es opcional, a continuación se
muestran ejemplos con y sin estas constantes:
>> r=dsolve(‘D2y+3*Dy+2*y=0’)
r =
C1*exp(-t)+C2*exp(-2*t)
>> s=dsolve(‘D2y+3*Dy+2*y=0′,’Dy(0)=l,y(0)=0’)
s =
exp(-t)-exp(-2*t)
>> S=dsolve(‘D2y+3*Dy+2*y=cos(t)’,’Dy(0)=l,y(0)=0′)
S =
1/l0*cos(t)+3/l0*sin(t)+1/2*exp(t)-3/5*exp(-2*t)
d y
dt
dy
dt
y
2
2 + 3 + 6 = 0
CÁLCULO SIMBÓLICO 29
2.4. TRANSFORMACIÓN DE LAPLACE E INVERSA
La transformación de Laplace calcula la integral:
permite transformar f(t) en el dominio del tiempo, a (s), en el dominio de la
variable compleja
>> syms a w t s
>> F=cos(w*t)*exp(–a*t)
F =
cos(w*t)*exp(–a*t)
>> L=laplace(F,t,s)
L =
(s+a)/((s+a)^2+w^2)
>> pretty(L)
(s + a)
———–
2 2
(s + a) + w
>> L1=laplace(exp(-t),t,s)
L1 =
1/(l+s)
>> pretty(L1)
1
—-
1 + s
La transformada inversa se ejecuta sobre expresiones de la variable compleja
s, para volver al dominio del tiempo.
>> I=ilaplace(L,s,t)
I =
cos(w*t)*exp(-a*t)
>> I1=ilaplace(Ll,s,t)
I1 =
exp(-t)
(s) = f (t) ⋅ e– s tdt ∞ ⋅ ∫0
30 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
2.5. LÍMITES
>> limit(1/x,x,0,’left’)
ans =
-inf
El límite de 1/x, cuando la variable x tiende a 0 por la izquierda, es –∞.
>> Lim=limit((x^3-1)/(x^2-l),x,1)
Lim =
3/2
2.6. SERIES DE TAYLOR Y MAC LAURIN
Para obtener desarrollos de series de Taylor y Mac Laurin, se utiliza indistintamente
taylor, con 3 o 4 argumentos:
>> syms x
>> f=exp(-x);
>> pretty(taylor(f,x,3,8))
2
exp(-8) – exp(-8) (x – 8) + 1/2 exp(-8) (x – 8)
>> pretty(taylor(f,x,3))
2
1 – x + 1/2 x
2.7. INVOCANDO A MAPLE V
Desde MatLab se accede a Maple V con la función maple, que toma
como argumento la expresión con sintaxis de Maple V, mediante las instrucciones
genéricas:
r=maple(‘Sentencia Maple’)
r=maple(‘Función’,Argl,Arg2,…)
2.7.1. Transformación de Laplace e inversa con Maple V
Para comenzar a utilizar las funciones de MapleV, relacionadas con la
transformación de Laplace, es necesario cargar previamente el paquete de
transformaciones integrales with(inttrans):
>> maple(‘with(inttrans)’) % Se carga el paquete de …
% transformaciones integrales.
CÁLCULO SIMBÓLICO 31
ans =
[addtable, fourier, fouriercos, fouriersin, hankel, hilbert,…
invfourier, invhilbert, invlaplace, invmellin, …
laplace, mellin, savetable]
>> maple(‘laplace(y(t)=t^2+sin(t),t,s)’)
ans =
laplace(y(t),t,s) = 2/s^3+1/(s^2+1)
>> M1=maple(‘invlaplace((s+1)/(s*(s^2+s+1)),s,t)’)
M1 =
1+1/3*exp(-1/2*t)*3^(1/2)*sin(1/2*3^(1/2)*t)-exp(-1/2*t)*…
cos(1/2*3^(1/2)*t)
2.7.2. Resolución de ecuaciones diferenciales con Maple V
Para resolver la ecuación diferencial:
ÿ + 3 y · + 6y = 0
con condiciones iniciales:
y ·
(0) = 3
y (0) = 0
se procede con las siguientes instrucciones:
>> maple(‘eq:=diff(y(t),t$2)+3*diff(y(t),t)+6*y(t)=0’)
ans =
eq := diff(y(t),’$'(t,2))+3*diff(y(t),t)+6*y(t) = 0
>> maple(‘ini:=y(0)=0,D(y)(0)=3’)
ans =
ini := y(0) = 0, D(y)(0) = 3
>> maple(‘Sol:=dsolve({eq,ini},{y(t)})’)
ans =
Sol := y(t) = 2/5*15^(1/2)*exp(-3/2*t)*sin(1/2*15^(1/2)*t)
32 INTRODUCCIÓN RÁPIDA A MATLAB Y SIMULINK PARA CIENCIA E INGENIERÍA
2.7.3. Resolución de ecuaciones diferenciales con la transformación
de Laplace
Para resolver la ecuación diferencial:
ÿ – 2 y · – 3y = 0
con condiciones iniciales:
y ·
(0) = 1
y (0) = 0
se procede con las siguientes instrucciones:
>> maple(‘eq:=diff(y(t),t$2)-2*diff(y(t),t)-3*y(t)=0’)
ans =
eq := diff(y(t),’$'(t,2))-2*diff(y(t),t)-3*y(t) = 0
>> maple(‘ini:=y(0)=0,D(y)(0)=1’)
ans =
ini := y(0) = 0, D(y)(0) = 1
>> maple(‘La:=laplace(eq,t,s)’)
ans =
La := s*(s*laplace(y(t),t,s)-y(0))-D(y)(0)-2*s* …
laplace(y(t),t,s)+2*y(0)-3*laplace(y(t),t,s) = 0
>> Maple(‘Sol:=subs(ini,{La})’)
ans =
Sol := {s^2*laplace(y(t),t,s)-1-

Web del Autor

Clic Aqui Pagina Oficial

Si no sabes descargar mira este video tutorial

[sociallocker]
[popfly]

Descargar 

Leer en online
[/popfly] [/sociallocker]

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

error: Content is protected !!
---------