Laboratorio Métodos Numéricos
Errores por truncamiento y redondeo
Dr. Victor Sánchez Urrutia
1. Objetivos
Entender sobre las fuentes de error en algorítmos numéricos.
Aprender a usar Scilab para programar, graficar y realizar explora-
ciones numéricas.
2. Uso de ésta guía
Esta guía de laboratorio contiene:
1. Parte de la teoría requerida para poder realizar y entender el ex-
perimento numérico propuesto, recomendamos que lea bien ésta
guía antes del principio de la sesión de laboratorio.
2. Una serie de pasos o acciones que deben ejecutar en el laboratorio.
Para que sea más fácil de localizar estos pasos dentro del docu-
mento, éstos serán resaltados de la siguiente manera:
Paso 0
Este es un ejemplo de como aparecerán los pasos a acciones a
realizar. Fijesé que está enumerado.
3. Además de las acciones a tomar se les harán preguntas o se les
pedirá que realice trabajo extra. Estas preguntas o trabajos extras
son los que deben entregarse como su informe de laboratorio. Para
que sea fácil localizarlas y no se le olvide, las resaltaremos de la
siguiente manera:
0
Ejemplo: Modificar el programa xxx para que calcule otra co-
sa. Entregue el programa en su informe. ¿Piensa usted que la
nueva versión es más rápida?
4. En algunas situaciones haremos comentarios importantes que in-
dicaremos de la siguiente manera:
División entre cero
Al calcular el error aproximado, se puede dar el caso que el
nuevo o “mejor” valor sea cero y por consiguiente el error
aproximado sea infinito...
Los informes de laboratorio deben ser entregados antes del labora-
torio siguiente. El informe debe estar contenido en una archivo Word u
OpenOffice con todas sus gráficas y tablas incluida en el mismo docu-
mento. Debe tratar de que su escritura sea coherente y todas las pregun-
tas que se le hicieron en la guía estén contempladas. Si se le pide que
haga o modifique programas estos deben ser entregados en archivos
aparte, también cualquier archivo de datos utilizados.
Estos archivos serán entregados según instrucción del profesor o pro-
fesor de laboratorio utilizando la plataforma Moodle.
3. Fundamentos teóricos
La función exponencial se calcula evaluando la serie siguiente:
∞
x
X xn
e =1+ (1)
n=1
n!
donde n! corresponde al factorial de n:
n
Y
n! = n × n − 1 × . . . × 1 = m (2)
m=1
= n × (n − 1)!; 1! ≡ 1 Forma recursiva (3)
y, como sabemos, para un exponente entero:
n
Y
n
x = x (4)
m=1
= x × x n−1 ; x1 ≡ x Forma recursiva (5)
Para implementar la serie (1) es mucho más eficiente usar las formu-
laciones recursivas.
Sin embargo, obviamente ¡no se puede realizar la sumatoria en (1)
hasta el infinito! Lo que hay que hacer evaluar la serie hasta que el re-
sultado sea lo suficientemente bueno. O sea, que la evaluación de la serie
debe detenerse luego que el error del cálculo menor que un techo desea-
do. Este error, el que ocurre al cortar el cálculo de una serie, se le conoce
como error de truncamiento.
El error real de cálculo aproximado se define como,
valor aproximado − valor real
er = (6)
valor real
Al realizar métodos numéricos generalmente no conocemos el valor
real de un cálculo (si lo tenemos ¿para que estamos calculandolo si ya lo
tenemos?), en vez de eso se usa un error aproximado.
En un algoritmo tipo iterativo, esto se hace asumiendo que cada ite-
ración mejora el estimado de la respuesta, de manera que la última ite-
ración se toma como el “valor real” o verdadero:
valor penúltima iteración − valor última iteración
ea =
(7)
valor última iteración
Si aplicamos la ecuación (7) en la iteración i a nuestro problema te-
nemos que:
Pi−1 x n Pi xn
1 + n=1 − (1 + )
n! n=1 n!
ea = Pi xn
(8)
1 + n=1 n!
i
− xi!
= Pi n
(9)
1 + n=1 xn!
último término de la serie calculado
= (10)
último valor calculado
4. Implementación
Paso 1
Escriba la siguiente rutina para calcular la función exponencial.
Guardela en un archivo llamado miexp.sci.
1 function [ res , n ] = miexp ( x , err_max )
2 // Función que calc ula l a exponencial
3 // x : exponente de e
4 // err_max : máximo error aproximado permitido
5 // res : resultado ( e^x )
6 // n : cantidad de i t e r a c i o n e s
7
8 // Arrancamos dando l a s condiciones i n i c i a l e s
9 n = 1; // Contador de i t e r a c i o n e s
10 res = 1 ; // Resultado f i n a l 1 + sum ( . . . )
11 xn = x ; // variable que guarda x^n
12 nfact = 1 ; // variable que guarda n !
13 err_aprox = 100; // En l a primera i t e r a c i o n no t i e n e s e n t i d o hablar
14 // de error , pero necesitamos empezar con algo para
15 // que e l c i c l o " while " pueda arrancar
16
17 // Iteramos hasta que e l próximo
18 // término sea menor o igual err_max
19
20 while err_aprox > err_max
21
22 termino = xn/ nfact ; // Término de l a s e r i e
23
24 res = res + termino ; // Nuevo valor mejorado
25
26 // Cálculo del error , lea e l comentario sobre é s t e c á l c u l o en l a guía
27
28 err_aprox = abs ( termino/ res ) ;
29
30 // Cuando uno está probando un nuevo programa es importante
31 // examinar que está pasando para poder " depurar " e l programa
32 // y ver s i hay errores . Es común poner i n s t r u c c i o n e s para imprimir
33 // resultados p a r c i a l e s . No tenga pereza de poner tantos comandos
34 // de impresión como sea necesario .
35 // Cuando usted e s t é seguro que e l programa corre bien , entonces puede
36 // ponerle un // antes para c o n v e r t i r l a en un comentario
37
38 // f í j e s e que l o s dos puntos a l f i n a l de l a l i n e a indica que e l
39 // comando sigue en otra l í n e a . S i no l o s pone l e s va a dar un error .
40
41 pr intf ( " I t e r : %i , res : %e, Termino : %e, Error aprox : %e\n" , . .
42 n , res , termino , err_aprox )
43
44 n = n+1; // Aumentamos e l contador de i t e r a c i ó n .
45 xn = xn * x ; // Uso de l a formulación recursiva para c a l c u l a r x^n
46 nfact = nfact * n ; // Uso de l a formulación recursivas para c a l c u l a r n !
47 end ;
48
49 endfunction
Paso 2
En Scilab, cargue la función (use F5) y asegurese que no hay errores
de sintaxis. Ejecute la instrucción format(25) lo que hará que Sci-
lab imprima los resultados con todas las cifras disponibles. Pruebe
la rutina con x = 5 y err_max = 1D-4 comparela con la función
exp(x) definida en Scilab.
Para probar nuestra rutina para calcular la exponencial, comparare-
mos el resultado con la función exp(x) provista por Scilab. Por supuesto
que Scilab también calculará esa función usando un método numérico,
pero las bibliotecas numéricas usadas por Scilab son muy buenas y están
bien probadas.
En la vida real no siempre contaremos con ese lujo a la hora de pro-
bar nuestros programas y tendremos que probar el programa corriendo
casos conocidos o en donde tenemos una buena idea de cual es un re-
sultado probable. En la práctica, para problemas complejos tendremos
que realizar experimentos reales para comprobar nuestros resultados.
Paso 3
Ahora llame a la función con valores de error permitido cada vez
más pequeños: 1D-6,1D-8,1D-10, etc. Compare con el resultado da-
do por Scilab. Fíjese como nuestra respuesta se va acercado más al
resultado dado por Scilab.
Al mismo tiempo, miren el “término” en cada iteración. Se ve que
va reduciéndose en cada iteración. Además, a medida que pedimos más
precisión (menor error) el número de iteraciones va aumentando. Lo que
vamos haciendo al aumentar las iteraciones es reducir el error por trun-
camiento. Al hacer más iteraciones la calidad de la respuesta va aumen-
tando... o por lo menos así debe ser si no aparecen otros problemas
numéricos en el camino.
Paso 4
Ahora, utilice un error de 1D-6 y vaya aumentando x a valores 10,
20, 50. Fíjese como el número de iteraciones va aumentando, revise
los términos también.
Todo parece ir bien. Ahora haremos una prueba con números negati-
vos.
Paso 5
Pruebe su programa con el mismo error pero ahora con x = −5.
Repita ahora con x = −50. Compare con la función de Scilab... ¿Qué
pasó aquí?
Nuestras ecuaciones están bien. No tenemos errores aparentes de
programación ya que funcionó para muchos valores y de forma correcta.
Lo que tenemos es otro problema importante al hacer cálculos nu-
méricos y se debe a los errores que provienen del hecho la computadora
tiene una capacidad limitada de representar números. Si estos números
fueran guardados con precisión completa eventualmente los negativos
cancelarían los positivos y el resultado sería muy cercano a cero. Pero
al ir perdiendo precisión esa cancelación no se da y ¡acabamos con un
enorme error!
Hay estrategias para reducir estos problemas...obviamente el que pro-
gramó la función exp() en Scialb supo resolver ese problema. Por suer-
te, la solución no es tan complicada. Ya sabemos que nuestro algoritmo
se comporta bien cuando el argumento es positivo. Entonces podemos
echar mano a algo conocido por nosotros:
e−x ≡ 1/ex (11)
1
Para tarea, modifique el programa dado de manera que si el argu-
mento es negativo entonces utilice ec. (11): haga el cálculo con el
argumento positivo y al final saque la inversa. Llame as su progra-
ma nuevo miexpneg.sci.
Para este laboratorio seguiremos con el programa que tenemos pero
usaremos solo números positivos.
Paso 6
Ahora defina un vector v con valores de 0 a 5 incrementando en .1:
v = 0:.1:5;
y calcule exp(v). Compare con miexp(v,0.0001). ¿Qué pasó? Tra-
te de arreglar miexp() para evitar el problema. Empiece por co-
mentar o eliminar la línea que imprime resultados (la línea 41 y 42).
No la necesitaremos ya que era principalmente para ver que estaba
haciendo el programa.
Es importante que sepa la diferencia que hace Scilab entre una ope-
ración matricial o vectorial y una operación elemento por elemento. Esto
es especialmente importante cuando usamos la multiplicación y expo-
nenciación. Para hacer la multiplicación matricial se usa el operador “*”
para hacer la operación por elementos se usa “.*”.
Los errores son ahora vectoriales
Hay una complicación. La evaluación del error se hará en varios
cálculos a la vez. Habrá que tomar el mayor error de todos para
decidir cuando parar los cálculos.
Otro problema es que arrancamos la función asumiendo que x era un
número y no una matriz, de manera que la variable res era inicializada
a número 1 y ahora debe ser inicializada a un vector de 1s. Hay que
cambiar la línea res líneas por res = ones(x). Mire en el manual de
Scilab que hace la función ones().
Siga tratando de buscar errores y arreglándolos.
5. Guiones y graficación
Paso 7
Escriba el siguiente guión o “script” en un archivo llamado
compara.sci. Córralo y observe las gráficas. Estudie como se obtu-
vieron las gráficas.
1 // E s t e guion ( s c r i p t ) s i r v e para
2 // i n v e s t i g a r e l comportamiento de l a
3 // aproximacion del exponencial .
4 // También i l u s t r a como graficar en S c i l a b .
5
6 // Los guiones no son funciones , s i no " programas " , no tienen argumentos
7 // de entrada ni s a l i d a s . Solo ejecutan una s e r i e de comandos .
8
9 // La función input pide un valor
10 err_max = input ( " Error máximo aproximado : " ) ;
11
12 // Vector de valores .
13 v = 0:0.1:5;
14
15 // E s t e c i c l o e j e c t u t a miexp para cada uno de l o s valores de v
16 // Y l o compara a l valor " verdadero " que s e r í a e l que da S c i l a b .
17
18 for n = 1 :max( size ( v ) )
19 [ apr ( n ) , i t e r ( n ) ] = miexp ( v ( n ) , err_max ) ;
20 verdadero = exp ( v ( n ) ) ;
21 errabs ( n ) = abs ( ( apr ( n)−verdadero ) / verdadero ) ;
22 end ;
23
24 // Grafica del error absoluto
25 scf ( 0 ) ;
26 clf ( ) ;
27
28 plot2d ( v , errabs ) ;
29 x t i t l e ( " Error r e l a t i v o de l a aprox . " , . .
30 " Valores del argumento " , " Error r e a l r e l a t i v o " )
31
32 // Grafica del numero de i t e r a c i o n e s
33
34 scf ( 1 ) ;
35 clf ( ) ;
36 plot2d ( v , i t e r ) ;
37 x t i t l e ( " Costo computacional " , . .
38 " Valores del argumento " , "Numero de i t e r a c i o n e s " )
2
En el paso anterior se modificó la función miexp() para que funcio-
nara con argumentos vectoriales como la función exp() de Scilab.
¿Porqué no usamos esa modificación para simplemente usar correr
el vector en una sola operación?
3
Modifique la función que calcula el exponencial de manera que cada
“termino” sea guardado en un arreglo o vector. Luego realice la su-
ma de los diferentes términos empezando del final hacia adelante y
compare con el resultado obtenido con la suma normal, de adelan-
te hacia atrás. Pruebe varios valores y use tolerancias bajas. ¿Cúal
método es más exacto? ¿Porqué?
Sugerencia: guarde los “termino” asignandolos a una varible: ej.
s(i)=termino (i es un contador). En Scilab no necesita definir el ta-
maño del arreglo, la variable “s” crecerá a medida que se asignan
nuevos valores
