matlab dispone de tres funciones útiles relacionadas con las operaciones de coma flotante
TRANSCRIPT
MATLAB dispone de tres funciones útiles relacionadas con las operaciones de coma flotante. Estas funciones, que no tienen argumentos, son las siguientes:
eps devuelve la diferencia entre 1.0 y el número de coma flotante inmediatamente superior. Da una idea de la precisión o número de cifras almacenadas. En un PC, eps vale 2.2204e-016.
realmin devuelve el número más pequeño con que se puede trabajar (2.2251e-308)realmax devuelve el número más grande con que se puede trabajar (1.7977e+308)
Detalles de Matlab
Formatos de Salida
Respecto a los formatos numéricos con que MATLAB muestra los resultados (recuérdese que siempre calcula y almacena con doble precisión, es decir con unas 16 cifras decimales equivalentes), las posibilidades existentes se muestran en la lista desplegable de la Figura 21 y son las siguientes:
short coma fija con 4 decimales (defecto)long coma fija con 15 decimaleshex cifras hexadecimalesbank números con dos cifras decimalesshort e notación científica con 4 decimalesshort g notación científica o decimal, dependiendo del valorlong e notación científica con 15 decimaleslong g notación científica o decimal, dependiendo del valorrat expresa los números racionales como cocientes de enteros
Estos formatos se pueden cambiar también desde la línea de comandos anteponiendo lapalabra format. Por ejemplo, para ver las matrices en formato long habrá que ejecutar el comando:
>> format long
MATLAB mantiene una forma especial para los números muy grandes (más grandes que los que es capaz de representar), que son considerados como infinito. Por ejemplo, obsérvese cómo responde el programa al ejecutar el siguiente comando:
>> 1.0/0.0Warning: Divide by zeroans =
Inf
Así pues, para MATLAB el infinito se representa como inf ó Inf. MATLAB tiene tambiénuna representación especial para los resultados que no están definidos como números. Por ejemplo, ejecútense los siguientes comandos y obsérvense las respuestas obtenidas:
>> 0/0Warning: Divide by zeroans =
NaN>> inf/infans =
NaN
En ambos casos la respuesta es NaN, que es la abreviatura de Not a Number. Este tipo derespuesta, así como la de Inf, son enormemente importantes en MATLAB, pues permiten controlar la fiabilidad de los resultados de los cálculos matriciales. Los NaN se propagan al realizar con ellos cualquier operación aritmética, en el sentido de que, por ejemplo, cualquier número sumado a un NaN da otro NaN. MATLAB tiene esto en cuenta. Algo parecido sucede con los Inf.
MATLAB dispone de tres funciones útiles relacionadas con las operaciones de coma flotante. Estas funciones, que no tienen argumentos, son las siguientes:
eps devuelve la diferencia entre 1.0 y el número de coma flotante inmediatamente superior. Da una idea de la precisión o número de cifras almacenadas. En un PC, eps vale 2.2204e-016.
realmin devuelve el número más pequeño con que se puede trabajar (2.2251e-308)realmax devuelve el número más grande con que se puede trabajar (1.7977e+308)
En muchos cálculos matriciales los datos y/o los resultados no son reales sino complejos, con parte real y parte imaginaria. MATLAB trabaja sin ninguna dificultad con números complejos. Para ver como se representan por defecto los números complejos, ejecútense los siguientes comandos:
>> a=sqrt(-4)a =
0 + 2.0000i>> 3 + 4jans =
3.0000 + 4.0000i
En la entrada de datos de MATLAB se pueden utilizar indistintamente la i y la j pararepresentar el número imaginario unidad (en la salida, sin embargo, puede verse que siempre aparece la i). Si la i o la j no están definidas como variables, puede intercalarse el signo (*). Esto no es posible en el caso de que sí estén definidas, porque entonces se utiliza el valor de la variable. En general, cuando se está trabajando con números complejos, conviene no utilizar la i como variable ordinaria, pues puede dar lugar a errores y confusiones. Por ejemplo, obsérvense los siguientes resultados:
>> i=2i =
2>> 2+3i
ans =2.0000 + 3.0000i
>> 2+3*ians =
8>> 2+3*j
ans =2.0000 + 3.0000i
Cuando i y j son variables utilizadas para otras finalidades, como unidad imaginaria puedeutilizarse también la función sqrt(-1), o una variable a la que se haya asignado el resultado de esta función.
MATLAB puede definir variables que contengan cadenas de caracteres. En MATLAB las cadenas de texto van entre apóstrofos o comillas simples (Nótese que en lenguaje C van entre comillas dobles: "cadena"). Por ejemplo, en MATLAB:
s = 'cadena de caracteres'
Las cadenas de texto tienen su más clara utilidad en temas que se verán más adelante y poreso se difiere hasta entonces una explicación más detallada.<p class=MsoNormal style='mso-layout-grid-align:none;text-autospac
Introducción al Matlab
El propósito de estas notas es hacer una rápida introducción al matlab. Son sólo unas pequeñas
muestras para dar idea de como funciona este programa. Para un estudio más serio deben consultarse otras referencias. En particular las que damos al final de esta página.
El nombre de Matlab viene de Matrix Laboratory y como el nombre indica matlab es especialmente fuerte en el tratamiento de matrices. Estos fueron sus orígenes, a los que se han ido incorporando sucesivamente más capacidades, sobretodo gráficas.
Matlab es una potente calculadora, por ejemplo calcula la suma de dos números
>> 2+2ans = 4
Aunque el ejemplo es sencillo ya vemos como actua matlab, se escriben las instrucciones en la línea de comandos >> y después de pulsar la tecla Intro aparece el resultado más abajo como variable ans. El resultado no aparece visible en la pantalla si ponemos punto y coma ; al final de las instrucciones, como en
>> A=rand(6); B=inv(A); B*A;
Si quitamos los puntos y comas de esta última expresión veremos el resultado. Para escribirla de nuevo podemos usar la flecha hacia arriba del teclado, que nos recupera los comandos escritos anteriormente en la sesión.
>> A=rand(6), B=inv(A), B*AA = 0.1338 0.4514 0.6831 0.0164 0.7176 0.1536 0.2071 0.0439 0.0928 0.1901 0.6927 0.6756 0.6072 0.0272 0.0353 0.5869 0.0841 0.6992 0.6299 0.3127 0.6124 0.0576 0.4544 0.7275 0.3705 0.0129 0.6085 0.3676 0.4418 0.4784 0.5751 0.3840 0.0158 0.6315 0.3533 0.5548B = -18.9422 -0.1768 -27.4583 8.2189 14.1721 17.0665 10.6427 -0.8112 14.3231 -3.3853 -9.0470 -7.7695 5.3157 -0.9261 7.4863 -1.8170 -2.6566 -5.1051 4.6141 -0.4972 6.8101 -3.2198 -2.1772 -3.1550 -9.7318 1.3315 -15.5596 3.3890 7.9718 9.3641 13.0642 0.4891 20.4944 -4.6187 -10.9522 -12.7382ans = 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0 0.0000 0 -0.0000 -0.0000 1.0000 0.0000 -0.0000 -0.0000 -0.0000 -0.0000 0.0000 1.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 0.0000 1.0000 0.0000 0.0000 -0.0000 0.0000 0 0.0000 1.0000
Obsérvese la rapidez con que se han calculado estas matrices A=rand(6) encuentra una matriz 6x6 de números aleatorios (cada uno entre 0 y 1), inv(A) calcula su inversa y luego comprobamos que B*A es la matriz identidad. Los números negativos que aparecen son debido al redondeo (en este caso
serían números muy pequeños, pero negativos).
Veamos como maneja matab los números:
>> pians = 3.1416>> format long>> pians = 3.14159265358979
Aunque nos da el valor de pi con distinto número de decimales en realidad matlab trabaja internamente con doble presición, pero nos muestra distintos formatos. Para ver los distintos formatos basta con usar el help:
>> help format (aparece el cuadro de la derecha -->) Ejemplo: 10*pi 10*exp(1)format short 31.4159format long 31.41592653589793format short e 3.1416e+001format long e 3.141592653589793e+001format short g 31.416format long g 31.4159265358979format hex 403f6a7a2955385eformat bank 31.42format rat 3550/113
27.182827.182818284590452.7183e+0012.718281828459045e+00127.18327.1828182845905403b2ecd2dd96d4427.182528/93
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.
All computations in MATLAB are done in double precision.
Cada número se guarda en memoria como un vector de 8 bytes, lo que da una mantisa de unos 15 ó 16 dígitos decimales. Al ser 8 bytes = 64 bits de memoria, cada bit es como si fuera una cajita donde se almacenan los ceros o unos corrspondientes al número en binario. De estas cajitas o bits, una de ellas corresponde al signo (+ ó -), 11 bits al exponente y el resto, esto es 52 bits a la mantisa. Un número x será por tanto
x= signo x mantisa x 10E
Los 211=2048 posibles exponentes E se distribuyen entre -1023 E 1024, siendo el número más grande posible del orden de (2-eps)*21023 x 10308 y el número más pequeño del orden de 2-1022 x10-308 . La mantisa de 52 bits nos da un epsilon máquina del orden de eps=2-
52x10-16. Recordenmos que el epsilon máquina eps se define como el número más grande eps tal que la máquina no distingue entre 1 y 1+eps.
El número real más grande, más pequeño y epsilon máquina respectivamente, se obtienen con
>>realmin>>realmax>>eps
Con matlab podemos ir escribiendo los comandos uno tras otro, pero cuando tenemos que hacer un pequeño programa o escribir muchos comandos suele resultar más útil escribir un fichero con las instrucciones y luego hacer que matlab los ejecute. Estos son los ficheros .m que no son más que ficheros de texto a los que luego ponemos la extensión .m . Matlab lleva incorporado un editor que podemos usar para
este propósito. Buscamos en File -> New -> M-file y escribimos en el editor que aparece
format longprimero=2.1;segundo=2.1for n=1:40 tercero=4*primero-3*segundo primero=segundo; segundo=tercero;end
que luego guardamos en matlab con el nombre diferencias.m , ya que lo que hace este programita es calcular los sucesivos términos de la sucesión an+2=4 an3 an+1 empezando con a1=2.1 y a2=2.1 En este caso, como no hemos puesto punto y coma después de la línea de tercero, los resultados se irán escribiendo en la pantalla, unos debajo de otros a medida que se van calculando.
2.100000000000002.100000000000002.100000000000002.099999999999992.100000000000022.099999999999912.100000000000362.099999999998542.100000000005822.099999999976722.100000000093132.099999999627472.100000001490122.099999994039542.100000023841862.099999904632572.100000381469732.099998474121092.100006103515632.099975585937502.100097656250002.099609375000002.101562500000002.093750000000002.1250000000000022.500000000000000.500000000000008.50000000000000-23.500000000000001.045000000000000e+002
El resultado es sorprendente !!
Esperaríamos ver que an=2.1, para todo n. ¿Por qué aparece este extraño comportamiento? En realidad la ecuación en diferencias an+2=4 an3 an+1 tiene por solución
donde siendo C1 y C2 dos constantes cualesquiera. Las condiciones iniciales a1=a2=2.1 determinan la solución con constantes C1=1, C2=0. Pero debido a que 2.1 en base dos tiene una fracción periódica que se repite indefinidamente, ya que
al calcular
tercero=tercero=4*primero-3*segundo,
resulta que si eps es un número muy pequeño comparable al epsilon máquina
-4.075000000000000e+0021.640500000000000e+003-6.551500000000000e+0032.621650000000000e+004-1.048555000000000e+0054.194325000000000e+005-1.677719500000000e+0066.710888500000000e+006-2.684354350000000e+0071.073741845000000e+008
a3=tercero=2.1+eps
al iterar ahora de nuevo con
a2=2.1, a3=2.1+eps, como nuevas condiciones iniciales, resulta que la constante C2 ya no es 0. Lo que hace que la solución errónea aumente exponencialmente y enmascare completamente la solución prevista. Es un claro ejemplo de inestabilidad numérica.
!No te fíes de los ordenadores!
Comentarios al programa:
1) Si añadimos la instrucción fprintf(' %16.7f\n ',segundo);
aparecerá una pantalla más ordenada con los resultados en columna.
2)
format longprimero=2.1;segundo=2.1;fi=fopen('resultados.txt','w');for n=1:40 tercero=4*primero-3*segundo; primero=segundo; segundo=tercero; fprintf(fi,'%16.7f\n',segundo);endfclose(fi)
Este programa abre un fichero de texto llamado resultados.txt donde se escribirán los cálculos en columna.
Buscar en
>> help fprintf
para más información sobre este y otros comandos parecidos.
3)
a(1)=2.1;a(2)=2.1;
Este otro programa tiene una estructura más apropiada para
for n=1:18 a(n+2)=4*a(n+1)-3*a(n); end
Matlab ya que va incrementando las componentes de un vector a. Que luego se puede usar , por ejemplo, para representar gráficamente como>>plot(a)
Ver>>whos
para observar las variables que están en memoria y como van cambiando.
En matlab hay unos añadidos llamados Toolboxes que incorporan más funciones y posibilidades. Una de ellas, que se incorpora en todas las versiones de Matlab para estudiantes, se llama Symbolic Toolbox. Con ella podemos trabajar con el número de dígitos de mantisa que deseemos, esta función es vpa. Buscar en help vpa. El ejemplo siguiente nos da los 800 primeros dígitos de pi: >> vpa(pi,800)ans =3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253 421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446 229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266 482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305 488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627 495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437 027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787 214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747 713099605187072113499999983729780499510597317328160963186
Como otro ejemplo, calculemos con mantisa 3 la suma de los primeros 20 términos de la serie armónica, esto es
clear all suma=1 for n=2:20 suma=vpa(vpa(suma,3)+vpa(1/n,3),3) end
El resultado que obtenemos es suma =3.60. De no haber calculado con esta mantisa obtendríamos>> suma =3.59773965714368
suma=0; tic for m=1:20 for n=1:1000*m suma=suma+1/n; end t(m)=toc; end plot(t)
El programita de aquí arriba utiliza una gráfica para representar el tiempo que ha tardado Matlab en sumar distintas sumas parciales de esta serie armónica. ¿Cuál es la suma de la serie armónica infinita? Todos sabemos que diverge, esto es, que si vamos sumando más y más términos las sumas parciales se hacen tan grandes como queramos. Hay una manera divertida de pensar en la suma de los términos de una serie. Se puede pensar que tenemos una pulguita que va dando saltitos, cada vez, en este caso, primero de un metro, luego de medio, luego de una tercera parte, y así sucesivamente. Esto es que en el salto n avanzaría una distancia 1/n. Que esta serie diverge significa que si el número de saltos es suficientemente grande nuestra amiga llegaría de la Autónoma a Madrid, a la Luna, ... llegaría tan lejos como queramos. !!Pero si la calculamos con el ordenador esta suma sería finita !!
¿Has pensado en cuál sería la suma?
Tal como hemos dicho Matlab está muy adaptado al cálculo con vectores y matrices, por ejemplo en las siguientes instrucciones
>> x=[0 : 0.1 : 1]
significa que x es un vector cuyas componentes empiezan en 0, se van incrementando de 0.1 en 0.1 y terminan en 1. Luego >>y=sin(x)
es un vector cuyas componentes son los senos de las anteriores, >>disp([x' y' z'])
muestra los traspuestos de estos vectores. El resultado se puede ver como sigue: >> x=[0:0.1:1]; y=sin(x); z=cos(x);>> '------------------------------------------------------- '>> ' x seno(x) cos(x) ', disp([x' y' z'])ans = x seno(x) cos(x) ---------------------------------------------------------- 0 0 1.00000000000000 0.10000000000000 0.09983341664683 0.99500416527803 0.20000000000000 0.19866933079506 0.98006657784124 0.30000000000000 0.29552020666134 0.95533648912561 0.40000000000000 0.38941834230865 0.92106099400289 0.50000000000000 0.47942553860420 0.87758256189037 0.60000000000000 0.56464247339504 0.82533561490968 0.70000000000000 0.64421768723769 0.76484218728449 0.80000000000000 0.71735609089952 0.69670670934717 0.90000000000000 0.78332690962748 0.62160996827066 1.00000000000000 0.84147098480790 0.54030230586814
En Matlab podemos escribir un conjunto de instrucciones que forman un fichero.m, pero también podemos utilizar una function. Hay una diferencia entre ambos ya que en un fichero.m los datos y las variables son como si las hubiérmos escrito desde la consola. En una función las variables son internas, no cambian ni afectan las externas. Por cierto que conviene muchas veces limpiar las variables externas con la instrucción
>>clear all
si no queremos tener cálculos confusos. Para limpiar la pantalla usaremos >>clc
Un ejemplo de función sería el programita siguiente, que calcula los 20 primeros términos de la serie exponencial
function [s]=serie(x) term=1; suma=1; for n=1:20 term=term*x/n; suma=suma+term; end s=suma
La función se llama desde la consola como
>>serie(x),
Por ejemplo: >>serie(1) suma=2.71828182845905
Resultado que ya da todas las cifras decimales correctas del numero e hasta la precisión de Matlat, como se puede comprobar fácilmente. Con esta función podemos comprobar por ejemplo que al sumar una suma alternada afecta en mucho el error de redondeo, ya que
>> exp(-8)-serie(-8) ans = -0.13229825662640
Mientras que
>> 1/serie(8)-exp(-8) ans =3.152568231321777e-008
Gráficos con Matlab
Pueden verse en los siguientes ejemplos:
Un comando útil en matlab es ginput. Ver >>help gineput (también gtext). Abajo el pequeño programita dibuja y=x(x-1)sin x, luego sobre la figura, permite tomar 6 puntos con el ratón, que
al final muestra en la consola.
>> f='x*(x-1)*sin(x)'; ezplot(f);[x,y]=ginput(6); [x,y] >> help plot
Various line types, plot symbols and colors may be obtained with PLOT(X,Y,S) where S is a character string made from one element from any or all the following 3 colunms:
y yellow . point - solid m magenta o circle : dotted c cyan x x-mark -. dashdot r red + plus -- dashed g green * star b blue s square w white d diamond k black v triangle (down) ^ triangle (up) < triangle (left) > triangle (right) p pentagram h hexagram Otros ejemplos:
Ventana de comandos de matlab
close all u=-8:0.5:8; v=u; [U,V]=meshgrid(u,v); R=sqrt(U.*U+V.*V)+eps; W=sin(R)./R; mesh(W)
x=[-3:0.4:3]; y=x; close subplot(2,2,1) figure(gcf), fi=[-6*pi:pi/20:6*pi]; plot3(fi.*cos(fi),fi.*sin(fi),fi,'r') [X,Y]=meshgrid(x,y); Z=superficie(X,Y); subplot(2,2,2) mesh(Z) subplot(2,2,3) surf(Z) subplot(2,2,4) contour3(Z,16)
>>[x y z]=peaks; >>contour(x,y,z,'k') >>pcolor(x,y,z) >>shading interp >>Z=peaks; >> figure (2); [C,h]=contour(Z,10); >> clabel(C,h)
produce las siguientes figuras:
>> help elfun
Trigonometric. sin - Sine. sinh - Hyperbolic sine. asin - Inverse sine. asinh - Inverse hyperbolic sine. cos - Cosine. cosh - Hyperbolic cosine. acos - Inverse cosine. acosh - Inverse hyperbolic cosine. tan - Tangent. tanh - Hyperbolic tangent. atan - Inverse tangent. atan2 - Four quadrant inverse tangent. atanh - Inverse hyperbolic tangent. sec - Secant. sech - Hyperbolic secant. asec - Inverse secant.
Exponential. exp - Exponential. log - Natural logarithm. log10 - Common (base 10) logarithm. log2 - Base 2 logarithm and dissect floating point number. pow2 - Base 2 power and scale floating point number. sqrt - Square root. nextpow2 - Next higher power of 2.
Complex. abs - Absolute value. angle - Phase angle. complex - Construct complex data from real and imaginary parts. conj - Complex conjugate. imag - Complex imaginary part. real - Complex real part. unwrap - Unwrap phase angle. isreal - True for real array.
asech - Inverse hyperbolic secant. csc - Cosecant. csch - Hyperbolic cosecant. acsc - Inverse cosecant. acsch - Inverse hyperbolic cosecant. cot - Cotangent. coth - Hyperbolic cotangent. acot - Inverse cotangent. acoth - Inverse hyperbolic cotangent.
cplxpair - Sort numbers into complex conjugate pairs.
Rounding and remainder. fix - Round towards zero. floor - Round towards minus infinity. ceil - Round towards plus infinity. round - Round towards nearest integer. mod - Modulus (signed remainder after division). rem - Remainder after division. sign - Signum.
Ver también
>>help specfun (Bessel , gamma, Airy).>>help mfun>>mfunlist (Zeta de Riemann, Polinomios ortogonales)
cardioide:>>ezpolar('1+cos(t)')
Otros comandos útiles de matlab:
>> date>> calendar>> clear x, clear all limpia la variable x, limpia todas las variables>> close , close all cierra la figura actual, cierra todas las figuras
>> axis([minx maxx miny maxy]) encuadra figura en este marco>> break sale de dentro de un “if” o de un “while”>> clc limpia la pantalla Control C (ó Control Z) acaba con la ejecución de un cálculo de matlab (en caso necesario).
Un juego: Vamos a mandar mensajes secretos
Julio César se comunicaba con sus gobernadoresy generales con mensajes codificados. Hacía corresponder a cada letra del abecedario la tercera siguiente. El mensaje parecía una sopa de letras ininteligible. Para decodificar no había más que proceder al revés. Aquí tenemos en cuenta que las letras y símbolos del teclado tienen asignados números enteros del 0 al 127, código ASCII. El comando char asigna este número a las letras mientras que rem (p,q) es el resto de dividir p entre q (clase de restos). El resultado es el siguiente:
» texto='Me encanta este curso'texto = Me encanta este curso» secreto=char(rem(texto+3,128)) secreto = Ph#hqfdqwd#hvwh#fxuvr» decodifica=char(rem(secreto-3,128)) decodifica = Me encanta este curso
Un programita de regalo: tetris.m
Refencias: http://www.glue.umd.edu/~nsw/ench250/primer.htm
http://mate.uprh.edu/~pnm/notas4061/cap2/repre.html
http://www.ticalc.org/pub/v200/basic/science/ programas para la voyage