Está en la página 1de 2

Errores de redondeo en una computadora

Aparecen dos tipos de situaciones en los que aparecen muchos errores por
redondeo:
1) si se suma (o se resta) un número muy pequeño de uno muy grande
2) Además, cuando un número se resta de otro que es muy cercano.

Para probar el primer caso en la computadora, sumemos 0.00001 a la


unidad
diez mil veces. El diseño de un programa para este trabajo seria:
𝒔𝒖𝒎𝒂 = 𝟏
𝒇𝒐𝒓 𝒊 = 𝟏 𝒕𝒐 𝟏𝟎𝟎𝟎𝟎
𝒔𝒖𝒎𝒂 = 𝒔𝒖𝒎𝒂 + 𝟎. 𝟎𝟎𝟎𝟎𝟏
𝒏𝒆𝒙𝒕
𝒑𝒓𝒊𝒏𝒕"SUMA=; "𝒔𝒖𝒎𝒂
El programa nos arroja un resultado de la suma=1.100136, cuando se sabe que
la suma es de 1.1 esto tiene una explicación del porque la computadora nos
arroja el valor de 1.100136 y no de 1.1, para explicar cómo surge estos errores
veamos el siguiente ejemplo.

ENTONCES EL ERROR RELATIVO DE CÁLCULO:


El resultado de este programa en la IBM PC es
SUMA=1.100136
respuesta exacta = 1. 1
𝟏. 𝟏 − 𝟏. 𝟏𝟎𝟎𝟏𝟑𝟔
. 𝟎𝟏𝟐 ( ) 𝒙𝟏𝟎𝟎 = −𝟎𝟒%
𝟏. 𝟏

Consideremos la siguiente suma:


1+0.00001 en la IBM PC.
Pasemos a base binario (base 2) ambos números por separado
Para el (𝟏)𝟏𝟎
(𝟏)𝟏𝟎 = (𝟏. 𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 )𝟐
Pasamos a normalizar dicho número.

(𝟏)𝟏𝟎 = (𝟎. 𝟏𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 )𝟐 𝒙𝟐𝟏


Para el (𝟎. 𝟎𝟎𝟎𝟎𝟏)𝟏𝟎
(𝟎. 𝟎𝟎𝟎𝟎𝟏)𝟏𝟎 = (𝟎. 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟏𝟎𝟏𝟎 𝟎𝟏𝟏𝟏 𝟏𝟏𝟎𝟎 𝟎𝟏𝟎𝟏 𝟏𝟎𝟏𝟎 𝟏𝟏𝟎𝟎 )𝟐
Pasamos a normalizar dicho número.

(𝟎. 𝟎𝟎𝟎𝟎𝟏)𝟏𝟎 = (𝟎. 𝟏𝟎𝟏𝟎 𝟎𝟏𝟏𝟏 𝟏𝟏𝟎𝟎 𝟎𝟏𝟎𝟏 𝟏𝟎𝟏𝟎 𝟏𝟏𝟎𝟎 )𝟐 𝒙𝟐−𝟏𝟔
Entonces al sumar los números tenemos lo siguiente.

(𝟏)𝟏𝟎 + (𝟎. 𝟎𝟎𝟎𝟎𝟏)𝟏𝟎 = (𝟎. 𝟏𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟎𝟎𝟎 𝟎𝟏𝟎𝟏 𝟎𝟎𝟏𝟏 𝟏𝟏𝟏𝟎 𝟎𝟎𝟏𝟎 𝟏𝟏𝟎𝟏 𝟎𝟏𝟏𝟎 𝟎)𝟐 𝐱𝟐𝟏

Ahora procedemos almacenar en una memoria de 32 bits

0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 1

signos Exponente 8 bits Mantisa 23 bits

EXPLICACIÓN DEL PROBLEMA:


Según al observar en la mantisa solo cabe 23 dígitos entonces a partir del digito
24 (de la flecha en adelante) los números sobrantes son redondeados, puesto que
la capacidad del almacenamiento en una memoria de 32 bits la mantisa solo
puede almacenar 23 dígitos, es ahí donde surge el error, porque no tiene más
capacidad para almacenar los dígitos sobrantes.

Así, siempre que se sume 0.00001 a 1, el resultado agrega 0.0000000136


como
error. Al repetir diez mil veces la suma de 0.00001 a 1, se genera un error
de exactamente
Diez mil veces 0.0000000136.
Es decir:
1+ (0.00001x10000) + (0.0000000136x10000) =1.100136

CONCLUSION DEL PROBLEMA:

Si Cuando almacenamos el mismo número en una memoria de 64


bits el error será mucho menor puesto que tiene una mayor
capacidad de almacenamiento.

si el número cambiado a sistema binario es periódico sería más


conveniente almacenar en una memoria de 64 bits ya que
tendríamos más espacio, pero igual nos resultaría un error.