Universidad de Murcia

Facultad de Informática

Cálculo numérico

Prácticas algoritmo de bisección

Juan Mompeán Esteban

email: juan.mompean@um.es

ITI de Sistemas

March 5, 2010
1 Introducción
He utilizado MAXIMA para resolver los ejercicios de la práctica sobre el
método de bisección y he implementado el siguiente algoritmo de bisección:
bisec(arg):=block([a:arg[1],b:arg[2],g:arg[3],xm:bfloat((arg[1]+arg[2])/2)],
if(ev(g,x=xm)*ev(g,x=a)¡=0)then[a,xm,g] else [xm,b,g]);

Como se puede ver el algoritmo de bisección recibe como parámetros un array

que contiene los valores del intervalo sobre el que aplicar bisección y la función
a evaluar en el intervalo. La bisección calcula el valor del punto medio del
intervalo y lo almacena en una variable, finalmente evalúa en que mitad del
intervalo se sigue cumpliendo el teorema de Bolzano y devuelve un array con
los nuevos valores del intervalo y la función. Se puede ver que el método de
bisección sólo se ejecuta una vez, mientras que para que el método de bisección
consiga un resultado razonablemente adecuado es necesario que se ejecute un
número elevado de veces. Como consecuencia es necesario implementar bucles
auxiliares que hagan sucesivas llamadas a la función bisección como ahora vere-
mos. También se debe tener en cuenta que la precisión interna que he utilizado
ha sido de 32 dı́gitos y la que muestra es de 16 dı́gitos.

2 Ejercicio 1
En este ejercicio hay que hayar las raices del siguiente polinomio:

x3 − 0.615x2 + 3.993x + 10−4 = 0

La gráfica del polinomo en el intervalo (-1,1) es esta:

La gráfica del polinomio en el intervalo (-0.0001,0.0001) es esta:

2
 Una vez analizada la función se ejecuta un bucle con el método de bisección
para calcular una aproximación a las raices. El bucle utilizado en este caso y su
salida son los siguientes (el intervalo inicial es el (-1,1)):

ini:[-1,1,x^3-0.615*x^2+3.993*x+10^-4]; for i:1 thru 50 do (print((ini[1])+0.0,",",ini[2]+0.0), ini:bisec(ini));

-1.0,1.0 -2.509355545043945b-5,-2.503395080566406b-5
-1.0,0.0b0 -2.506375312805176b-5,-2.503395080566406b-5
-5.0b-1,0.0b0 -2.504885196685791b-5,-2.503395080566406b-5
-2.5b-1,0.0b0 -2.504885196685791b-5,-2.504140138626099b-5
-1.25b-1,0.0b0 -2.504512667655945b-5,-2.504140138626099b-5
-6.25b-2,0.0b0 -2.504512667655945b-5,-2.504326403141022b-5
-3.125b-2,0.0b0 -2.504419535398483b-5,-2.504326403141022b-5
-1.5625b-2,0.0b0 -2.504419535398483b-5,-2.504372969269753b-5
-7.8125b-3,0.0b0 -2.504396252334118b-5,-2.504372969269753b-5
-3.90625b-3,0.0b0 -2.504384610801935b-5,-2.504372969269753b-5
-1.953125b-3,0.0b0 -2.504378790035844b-5,-2.504372969269753b-5
-9.765625b-4,0.0b0 -2.504375879652798b-5,-2.504372969269753b-5
-4.8828125b-4,0.0b0 -2.504374424461275b-5,-2.504372969269753b-5
-2.44140625b-4,0.0b0 -2.504373696865514b-5,-2.504372969269753b-5
-1.220703125b-4,0.0b0 -2.504373333067633b-5,-2.504372969269753b-5
-6.103515625b-5,0.0b0 -2.504373151168693b-5,-2.504372969269753b-5
-3.0517578125b-5,0.0b0 -2.504373060219223b-5,-2.504372969269753b-5
-3.0517578125b-5,-1.52587890625b-5 -2.504373014744488b-5,-2.504372969269753b-5
-3.0517578125b-5,-2.288818359375b-5 -2.504373014744488b-5,-2.50437299200712b-5 -
-2.6702880859375b-5,-2.288818359375b-5 2.504373014744488b-5,-2.504373003375804b-5
-2.6702880859375b-5,-2.47955322265625b-5 -2.504373014744488b-5,-2.504373009060146b-5
-2.574920654296875b-5,-2.47955322265625b-5 -2.504373011902317b-5,-2.504373009060146b-5
-2.527236938476563b-5,-2.47955322265625b-5 -2.504373010481231b-5,-2.504373009060146b-5
-2.527236938476563b-5,-2.503395080566406b-5 -2.504373009770688b-5,-2.504373009060146b-5
-2.515316009521484b-5,-2.503395080566406b-5 -2.504373009415417b-5,-2.504373009060146b-5

Podemos afirmar que la raiz se encuentra en el intervalo (−2.504373009415417∗

10− 5, −2.50437300906014 ∗ 10− 5), aunque como veremos en los siguientes ejer-
cicios ese intervalo no es tal, sino que debemos tener en cuenta los errores
derivados de su cálculo.

3
3 Ejercicio 2
1
Se nos pide que calculemos una aproximación de la fracción , para ello
2.5
1
utilizaremos la función f (x) = x − .
2.5

La gráfica de la función en el intervalo (0,1) es la siguiente:

Una vez analizada la gráfica vemos que hay una raiz entre 0 y 1 con lo que
aplicamos el método de bisección en ese intervalo. La instrucción en MAXIMA
es la siguiente:

ini:[0,1,x-0.4]; for i:1 thru 60 do (print((ini[1])+0.0,",",ini[2]+0.0), ini:bisec(ini));

0.0,1.0
0.0,5.0b-1
2.5b-1,5.0b-1
3.75b-1,5.0b-1
3.75b-1,4.375b-1
3.75b-1,4.0625b-1
3.90625b-1,4.0625b-1
3.984375b-1,4.0625b-1
3.984375b-1,4.0234375b-1
3.984375b-1,4.00390625b-1
3.994140625b-1,4.00390625b-1
3.9990234375b-1,4.00390625b-1
3.9990234375b-1,4.00146484375b-1
3.9990234375b-1,4.000244140625b-1
3.9996337890625b-1,4.000244140625b-1
3.99993896484375b-1,4.000244140625b-1
3.99993896484375b-1,4.000091552734375b-1
3.99993896484375b-1,4.000015258789062b-1
3.999977111816406b-1,4.000015258789062b-1
3.999996185302734b-1,4.000015258789062b-1
3.999996185302734b-1,4.000005722045898b-1
3.999996185302734b-1,4.000000953674316b-1
3.999998569488525b-1,4.000000953674316b-1
3.99999976158142b-1,4.000000953674316b-1
3.99999976158142b-1,4.000000357627868b-1
3.99999976158142b-1,4.000000059604644b-1
3.999999910593032b-1,4.000000059604644b-1
3.999999985098838b-1,4.000000059604644b-1
3.999999985098838b-1,4.000000022351741b-1
3.999999985098838b-1,4.00000000372529b-1
3.999999994412064b-1,4.00000000372529b-1
3.999999999068677b-1,4.00000000372529b-1
3.999999999068677b-1,4.000000001396983b-1
3.999999999068677b-1,4.00000000023283b-1
3.999999999650754b-1,4.00000000023283b-1
3.999999999941792b-1,4.00000000023283b-1
3.999999999941792b-1,4.000000000087311b-1
3.999999999941792b-1,4.000000000014551b-1
3.999999999978172b-1,4.000000000014551b-1
3.999999999996362b-1,4.000000000014551b-1

4
3.999999999996362b-1,4.000000000005456b-1
3.999999999996362b-1,4.000000000000909b-1
3.999999999998635b-1,4.000000000000909b-1
3.999999999999772b-1,4.000000000000909b-1
3.999999999999772b-1,4.000000000000341b-1
3.999999999999772b-1,4.000000000000056b-1
3.999999999999914b-1,4.000000000000056b-1
3.999999999999985b-1,4.000000000000056b-1
3.999999999999985b-1,4.000000000000021b-1
3.999999999999985b-1,4.000000000000003b-1
3.999999999999994b-1,4.000000000000003b-1
3.999999999999999b-1,4.000000000000003b-1
3.999999999999999b-1,4.000000000000001b-1
3.999999999999999b-1,4.0b-1
3.999999999999999b-1,4.0b-1
3.999999999999999b-1,4.0b-1
4.0b-1,4.0b-1
4.0b-1,4.0b-1
4.0b-1,4.0b-1
4.0b-1,4.0b-1

Como se puede ver al final de la ejecución los dos extremos del intervalo valen
0.4 con lo que podrı́amos decir que hemos hallado la solución y de hecho ası́
es. Aunque realmente lo que ha ocurrido es que hemos agotado la precisión
de MAXIMA y el resultado se ha aproximado a 0.4. Puesto que como ahora
veremos en todas las ejecuciones se están cometiendo errores.

Empezaremos por el error absoluto que he calculado con la siguiente in-

strucción de MAXIMA:
for i:1 thru 60 do print(((1-0)/(2^i))+0.0);

Esta función consiste simplemente en ir diviendo el tamaño del intervalo inicial

entre dos para cada una de las ejecuciones del método de bisección (60). El
resultado obtenido en cada ejecución del bucle será el error absoluto cometido
en esa ejecución

0.5 2.384185791015625 ∗ 10− 7 1.1368683772161603 ∗ 10− 13

−
0.25 1.1920928955078125 ∗ 10 7 5.6843418860808015 ∗ 10− 14
−
0.125 5.9604644775390625 ∗ 10 8 2.8421709430404007 ∗ 10− 14
−
0.0625 2.9802322387695312 ∗ 10 8 1.4210854715202004 ∗ 10− 14
−
0.03125 1.4901161193847656 ∗ 10 8 7.1054273576010019 ∗ 10− 15
−
0.015625 7.4505805969238281 ∗ 10 9 3.5527136788005009 ∗ 10− 15
−
0.0078125 3.7252902984619141 ∗ 10 9 1.7763568394002505 ∗ 10− 15
−
0.00390625 1.862645149230957 ∗ 10 9 8.8817841970012523 ∗ 10− 16
−
0.001953125 9.3132257461547852 ∗ 10 10 4.4408920985006262 ∗ 10− 16
− −
9.765625 ∗ 10 4 4.6566128730773926 ∗ 10 10 2.2204460492503131 ∗ 10− 16
− −
4.8828125 ∗ 10 4 2.3283064365386963 ∗ 10 10 1.1102230246251565 ∗ 10− 16
− −
2.44140625 ∗ 10 4 1.1641532182693481 ∗ 10 10 5.5511151231257827 ∗ 10− 17
− −
1.220703125 ∗ 10 4 5.8207660913467407 ∗ 10 11 2.7755575615628914 ∗ 10− 17
− −
6.103515625 ∗ 10 5 2.9103830456733704 ∗ 10 11 1.3877787807814457 ∗ 10− 17
− −
3.0517578125 ∗ 10 5 1.4551915228366852 ∗ 10 11 6.9388939039072284 ∗ 10− 18
− −
1.52587890625 ∗ 10 5 7.2759576141834259 ∗ 10 12 3.4694469519536142 ∗ 10− 18
− −
7.62939453125 ∗ 10 6 3.637978807091713 ∗ 10 12 1.7347234759768071 ∗ 10− 18
− −
3.814697265625 ∗ 10 6 1.8189894035458565 ∗ 10 12 8.6736173798840355 ∗ 10− 19
− −
1.9073486328125 ∗ 10 6 9.0949470177292824 ∗ 10 13
9.5367431640625 ∗ 10− 7 4.5474735088646412 ∗ 10− 13
−
4.76837158203125 ∗ 10 7 2.2737367544323206 ∗ 10− 13

5
 El número de dı́gitos correctos de cada iteración se puede deducir a partir del
error absoluto. Ası́ el número de dı́gitos correctos serı́a el número de dı́gitos que
tras restar o sumar el error absoluto al intervalo no vieran modificado su valor.
Por supuesto serı́an sólo los dı́gitos que estuvieran a la izquierda del primero
que modifica su valor.

Para calcular el error relativo usaremos esta función:

for i:1 thru 50 do print((((1-0)/(2^i))/0.4)*100,"%");

Como se puede ver el error relativo es el resultado de dividir el error abso-

luto entre la mejor aproximación que hayamos podido hallar para la raiz de la
función y multiplicarlo por 100. Los errores relativos para cada ejecución se
muestran a continuación:

125.0 9.5367431640625 ∗ 10− 4 7.2759576141834259 ∗ 10− 9

62.5 4.76837158203125 ∗ 10− 4 3.637978807091713 ∗ 10− 9
31.25 2.384185791015625 ∗ 10− 4 1.8189894035458565 ∗ 10− 9
15.625 1.1920928955078125 ∗ 10− 4 9.0949470177292824 ∗ 10− 10
7.8125 5.9604644775390625 ∗ 10− 5 4.5474735088646412 ∗ 10− 10
3.90625 2.9802322387695312 ∗ 10− 5 2.2737367544323206 ∗ 10− 10
1.953125 1.4901161193847656 ∗ 10− 5 1.1368683772161603 ∗ 10− 10
0.9765625 7.4505805969238281 ∗ 10− 6 5.6843418860808015 ∗ 10− 11
0.48828125 3.7252902984619141 ∗ 10− 6 2.8421709430404007 ∗ 10− 11
0.244140625 1.862645149230957 ∗ 10− 6 1.4210854715202004 ∗ 10− 11
0.1220703125 9.3132257461547852 ∗ 10− 7 7.1054273576010019 ∗ 10− 12
0.06103515625 4.6566128730773926 ∗ 10− 7 3.5527136788005009 ∗ 10− 12
0.030517578125 2.3283064365386963 ∗ 10− 7 1.7763568394002505 ∗ 10− 12
0.0152587890625 1.1641532182693481 ∗ 10− 7 8.8817841970012523 ∗ 10− 13
0.00762939453125 5.8207660913467407 ∗ 10− 8 4.4408920985006262 ∗ 10− 13
0.003814697265625 2.9103830456733704 ∗ 10− 8 2.2204460492503131 ∗ 10− 13
0.0019073486328125 1.4551915228366852 ∗ 10− 8

4 Ejercicio 3
En este ejercicio se nos pide que hallemos el número mı́nimo de ordenadores que
tiene que vender una empresa ensambladora para obtener beneficios. Para ello
se nos proporciona una fórmula que calcula los ingresos o pérdidas generados
tras la producción de un número x de ordenadores:
40 ∗ x1.5 − 875 ∗ x + 35000 = 0
Podemos ver la gráfica de la función en el intervalo (0,500) dónde se observa
que la función tiene dos raices. Sin embargo no vamos a considerar la menor de
las raices como una solución, ya que si la producción aumenta por encima de
ella la empresa comenzará a tener pérdidas. Mientras que nosotros queremos
saber a partir de que cantidad de ordenadores vendidos la empresa empezará a
obtener beneficios. Parece claro viendo el gráfico que la raı́z que nos interesa es
la segunda a partir de la cuál los beneficios se incrementa si aumenta el número
de ordenadores vendidos.

6
Hemos escogido el intervalo (384,384.5) para aplicar el método de bisección, de
tal modo que la instrucción en MAXIMA serı́a la siguiente:
ini:[384,384.5,40*x^1.5-875*x+35000]; for i:1 thru 40 do (print((ini[1])+0.0,",",ini[2]+0.0), ini:bisec(ini));

Y el resultado producido por esa instrucción es:

384.0,384.5
384.0,3.8425b2
384.0,3.84125b2
384.0,3.840625b2
384.0,3.8403125b2
3.84015625b2,3.8403125b2
3.84015625b2,3.840234375b2
3.8401953125b2,3.840234375b2
3.84021484375b2,3.840234375b2
3.84021484375b2,3.840224609375b2
3.8402197265625b2,3.840224609375b2
3.84022216796875b2,3.840224609375b2
3.84022216796875b2,3.840223388671875b2
3.84022216796875b2,3.840222778320312b2
3.840222473144531b2,3.840222778320312b2
3.840222625732421b2,3.840222778320312b2
3.840222702026367b2,3.840222778320312b2
3.840222740173339b2,3.840222778320312b2
3.840222759246826b2,3.840222778320312b2
3.840222768783569b2,3.840222778320312b2
3.840222768783569b2,3.84022277355194b2
3.840222771167755b2,3.84022277355194b2
3.840222772359848b2,3.84022277355194b2
3.840222772955894b2,3.84022277355194b2
3.840222773253917b2,3.84022277355194b2
3.840222773402929b2,3.84022277355194b2
3.840222773477435b2,3.84022277355194b2
3.840222773514688b2,3.84022277355194b2
3.840222773514688b2,3.840222773533314b2
3.840222773524001b2,3.840222773533314b2
3.840222773524001b2,3.840222773528657b2
3.840222773526329b2,3.840222773528657b2
3.840222773526329b2,3.840222773527493b2
3.840222773526911b2,3.840222773527493b2
3.840222773526911b2,3.840222773527202b2
3.840222773527057b2,3.840222773527202b2
3.840222773527129b2,3.840222773527202b2
3.840222773527129b2,3.840222773527166b2
3.840222773527148b2,3.840222773527166b2
3.840222773527157b2,3.840222773527166b2

El error absoluto se calcula igual que hicimos en el ejercicio anterior:

for i:1 thru 40 do (print((384.5-384)/2^i));

0.25 0.001953125
0.125 9.765625 ∗ 10− 4
0.0625 4.8828125 ∗ 10− 4
0.03125 2.44140625 ∗ 10− 4
0.015625 1.220703125 ∗ 10− 4
0.0078125 6.103515625 ∗ 10− 5
0.00390625 3.0517578125 ∗ 10− 5

7
1.52587890625 ∗ 10− 5
7.62939453125 ∗ 10− 6
3.814697265625 ∗ 10− 6
1.9073486328125 ∗ 10− 6
9.5367431640625 ∗ 10− 7
4.76837158203125 ∗ 10− 7
2.384185791015625 ∗ 10− 7
1.1920928955078125 ∗ 10− 7
5.9604644775390625 ∗ 10− 8
2.9802322387695312 ∗ 10− 8
1.4901161193847656 ∗ 10− 8
7.4505805969238281 ∗ 10− 9
3.7252902984619141 ∗ 10− 9
1.862645149230957 ∗ 10− 9
9.3132257461547852 ∗ 10− 10
4.6566128730773926 ∗ 10− 10
2.3283064365386963 ∗ 10− 10
1.1641532182693481 ∗ 10− 10
5.8207660913467407 ∗ 10− 11
2.9103830456733704 ∗ 10− 11
1.4551915228366852 ∗ 10− 11
7.2759576141834259 ∗ 10− 12
3.637978807091713 ∗ 10− 12
1.8189894035458565 ∗ 10− 12
9.0949470177292824 ∗ 10− 13
4.5474735088646412 ∗ 10− 13

Para calcular el error relativo se usa

for i:1 thru 40 do (print(((384.5-384)/2^i)/(384.0222773527166)*100));

Como se puede ver hemos escogido el menor valor del último intervalo generado
por el método de bisección, puesto que este es el más cercano a la raiz que
tenemos. Además sabemos que estamos teniendo en cuenta el mayor error
relativo posible al dividir por el menor valor posible para la raiz.

0.065100389936592 3.1042284935280002 ∗ 10− 8

0.032550194968296 1.5521142467640001 ∗ 10− 8
0.016275097484148 7.7605712338200004 ∗ 10− 9
0.008137548742074 3.8802856169100002 ∗ 10− 9
0.004068774371037 1.9401428084550001 ∗ 10− 9
0.0020343871855185 9.7007140422750005 ∗ 10− 10
0.0010171935927593 4.8503570211375003 ∗ 10− 10
−
5.0859679637962755 ∗ 10 4 2.4251785105687501 ∗ 10− 10
−
2.5429839818981377 ∗ 10 4 1.2125892552843751 ∗ 10− 10
−
1.2714919909490689 ∗ 10 4 6.0629462764218753 ∗ 10− 11
−
6.3574599547453443 ∗ 10 5 3.0314731382109377 ∗ 10− 11
−
3.1787299773726722 ∗ 10 5 1.5157365691054688 ∗ 10− 11
−
1.5893649886863361 ∗ 10 5 7.5786828455273442 ∗ 10− 12
−
7.9468249434316804 ∗ 10 6 3.7893414227636721 ∗ 10− 12
−
3.9734124717158402 ∗ 10 6 1.894670711381836 ∗ 10− 12
−
1.9867062358579201 ∗ 10 6 9.4733535569091802 ∗ 10− 13
−
9.9335311792896005 ∗ 10 7 4.7366767784545901 ∗ 10− 13
−
4.9667655896448003 ∗ 10 7 2.3683383892272951 ∗ 10− 13
−
2.4833827948224001 ∗ 10 7 1.1841691946136475 ∗ 10− 13
−
1.2416913974112001 ∗ 10 7
6.2084569870560003 ∗ 10− 8

Tal y como sucedı́a en el ejercicio 2 el número de dı́gitos correctos de cada

iteración se puede deducir a partir del error absoluto. Ası́ el número de dı́gitos
correctos serı́a el número de dı́gitos que tras restar o sumar el error absoluto al
intervalo no vieran modificado su valor. Por supuesto serı́an sólo los dı́gitos que
estuvieran a la izquierda del primero que modifica su valor.