Método del Intervalo Medio o Bisección

METODO DE LA BISECTRIZ

El método de la bisectriz es un método numérico sencillo,  muy versátil para encontrar una raíz real en un intervalo en el que existe una raíz.

Su singular ventaja consiste en que funciona incluso con funciones no analíticas; sin embargo, sólo se debe utilizar el método después de un análisis gráfico.

Supongáse que hay una raíz de f(x) = 0 en un intervalo entre;

x = a y x = c,

denotado por [a, c] o, de forma equivalente, por c ³ x ³ a.

El método de la bisectriz se basa en el hecho de que, cuando un intervalo [a, c] tiene una raíz, el signo de y(x) en los extremos es distinto, o sea, f(a) f(c) < 0.

El primer paso de este método consiste en bisectar el intervalo [a, c] en dos mitades: [a, b] y [b, c],  donde;

b = ( a + b ) / 2

Si se verifican los signos de f(a)f(b) y f(b)f(c), se sabe en que mitad del intervalo se encuentra la raíz.

De hecho, si 0 ³ f(a)f(b), el intervalo [a, b], que incluye x = a y x = b, contiene a la raíz; de lo contrario, la raíz esta en el otro intervalo, [b, c].

A continuación, se bisecta de nuevo el intervalo que contiene a la raíz.

Al repetir este procedimiento, el tamaño del intervalo que contiene a la raíz se hará cada vez más pequeño.

En cada paso se toma el punto medio del intervalo como la aproximación más actualizada a la raíz.

La iteración se detiene cuando el tamaño de la mitad del intervalo es menor que una tolerancia dada.

El tamaño del intervalo después de n pasos de iteración es

(c0- a0)/2n

donde a0 y c0 son valores iniciales, de modo que el numerador es el tamaño de intervalo inicial.

La ecuación anterior representa el máximo error que existe cuando se aproxima la raíz con el n-ésimo punto medio. Por tanto, si la tolerancia del error es t , el número de pasos de iteración necesarios es el entero n más pequeño que satisface

t ³( c0- a0)/2n

De forma equivalente, n ³ log[(c0- a0)/ t ]/log(2) donde t es la tolerancia.


Algoritmo:
1. Elija valores Iniciales para “a” y “b” de forma tal que lea función cambie de signo sobre el intervalo. Esto se puede verificar asegurandose de que :

f(a)*f(b) < 0
2. La primera aproximación a la raíz se determina con la formula:
xn = (a + b) / 2
3. Realizar las siguientes evaluaciones para determinar en que subintervalo se encuentra la raíz:
f(a)*f(xn ) < 0 Entonces  b = xn

f(a)*f(xn) > 0 Entonces  a = xn

f(a)*f(xn) = 0 Entonces xn Es la Raíz

4.  Calcule la nueva aproximación
xn+1  = (a + b) / 2
5. Evaluar la aproximación relativa
 | (xn+1  - xn ) / xn+1  | < Tolerancia

No. (Falso) Repetir el paso 3, 4 y 5

Si . (Verdadero) Entonces  xn+1   Es la Raíz

Down load el metodo de biseción Método de Bisección en Lenguaje C. en lenguaje C.


MatLAB
Para realizar este metodo en formato Matlab se procede como sigue:

Se utiliza la función bisec_g, para calculos de bisección.

La cual muestra gráficamente el avance de la iteración de bisección; en la figura resultante del matlab ilustra la gráfica final.

La sintaxis de bisec_g es la siguiente:

bisec_g(´nombre_f´, a, c, xmin, xmax, n_puntos)

Donde nombre_f es el nombre de la función que define la ecuación por resolver, a y c son los extremos del intervalo inicial, xmin y xmax son los valores mínimo y máximo de x en la gráfica, y n_puntos es el número de puntos que se usan para graficar la función.

La tolerancia es t = 10-6 por omisión.



bisec_g.m

function bisec_g(f_name, a,c, xmin, xmax, n_points)
f_name
%a, c : extremos del intervalo inicial
%tolerance:tolerancia
%It_limit:límite de el número de iteraciones
%Y_a, Y_c : valores de los extremos actuales
%fun_f(x): valor funcional en x
clg, hold off
clear Y_a, clear Y_c
wid_x= xmax-xmin; dx = (xmax-xmin)/n_points;
xp=xmin:dx:xmax;
yp = feval(f_name, xp);
plot (xp,yp); xlabel('x'); ylabel('f(x)');
title('Método de la bisectriz'), hold on
ymin=min(yp); ymax=max(yp); wid_y=ymax-ymin;
yp=0.*xp; plot(xp,yp);
fprintf('Método de la bisectriz: \n\n');
tolerance=0.000001; it_limit=30;
fprintf(' It. a b c fa=f(a) ');
fprintf(' fc=f(c) abs(fc-fa) \n');
it=0;
Y_a=feval(f_name,a);Y_c=feval(f_name, c);
plot([a,a], [Y_a,0]); text(a,-0.1*wid_y,'x=a')
plot([c,c], [Y_c,0]); text(c,-0.1*wid_y,'x=c')
if (Y_a*Y_c > 0) fprintf('f(a)f(c > 0 \n');
else
while 1
it=it+1;
b= (a+c)/2; Y_b=feval(f_name, b);
plot([b,b], [Y_b,0],':'); plot(b,0,'o')
if it<4, text(b,wid_y/20, [num2str(it)]),end
fprintf('%3.0f %10.6f, %10.6f', it, a, b);
fprintf(' %10.6f, %10.6f, %10.6f', c, Y_a, Y_c);
fprintf(' %12.3e\n', abs((Y_c-Y_a)));
if (abs(c-a)<=tolerance)
fprintf(' Se satisface la tolerancia. \n');break
end
if( it>it_limit )
fprintf(' Se exedio el limite de iteraciones. \n');break
end
if (Y_a*Y_b <= 0) c=b; Y_c=Y_b;
else a=b; Y_a=Y_b;
end
end
fprintf('Resultado final: Raíz=%12.6f \n',b);
end
x=b;
plot([x x],[0.05*wid_y 0.2*wid_y])
text(x, 0.25*wid_y, 'Solución final')
plot([x( x-wid_x*0.004)], [0.05*wid_y 0.09*wid_y])
plot([x( x+wid_x*0.004)], [0.05*wid_y 0.09*wid_y])