domingo, 29 de agosto de 2021

Métodos numéricos, Método de la Bisección para obtener raíces con Scilab

Método de la bisección

El método de bisección, también conocido como corte binario, de participación de intervalos o de Bolzano, es una técnica de búsqueda incremental que consiste en dividir un intervalo sucesivamente a la mitad.

Su funcionamiento se basa en la evaluación del valor de la función en el punto medio del intervalo. Si la función cambia de signo en dicho punto, se determina que la raíz se encuentra en uno de los subintervalos resultantes. El proceso se repite en el subintervalo que contiene el cambio de signo, dividiéndolo nuevamente a la mitad y evaluando la función en el nuevo punto medio.

Este proceso iterativo se continúa hasta que se alcanza la precisión deseada en la aproximación a la raíz.

Las principales ventajas del método de bisección son:

  • Simpleza y facilidad de comprensión.
  • No requiere información adicional sobre la función a evaluar.
  • Convergencia garantizada en la mayoría de los casos.

Sin embargo, también presenta algunas desventajas:

  • Convergencia lenta en algunos casos.
  • Precisión limitada en comparación con otros métodos numéricos.
  • No es aplicable para la búsqueda de raíces complejas.

En este ejemplo vamos a obtener las posibles raíces de la función siguiente :


\large f=3x-x^{2}-5x^{5}

Para poder resolverlo se usará el bloque de código siguiente :

Autor : Marco Polo Jácome Toss  
Fecha de creación :  29 de Agosto del 2021
Licencia : GNU General Public License (GPL) 3.0
Plataforma : Scilab, Método de la Bisección

La siguiente función es el método de la bisección.

// fun = function handle
// x = Intervalo de una posible raíz
// tol = Máxima tolerancia
// maxit = Máximo número de iteraciones
// Root: Raíz

clear; 
format("v",8)
clc
clear

function [root] = Bisection(fun,x,tol,maxit)

if fun(x(1)) > 0 then
    xu = x(1);    xl = x(2);
else
    xu = x(2);    xl = x(1);
end

Ea = 1;
iter = 1;

while(1)
    
    xr(iter) = (xl(iter) + xu(iter)) / 2;

    if fun(xr(iter)) > 0 then
        xu(iter+1) = xr(iter);
        xl(iter+1) = xl(iter);
    elseif fun(xr(iter)) < 0 then
        xl(iter+1) = xr(iter);
        xu(iter+1) = xu(iter);
    else
        break
    end
    
    if iter>1 then
        Ea(iter) = 100 * abs((xr(iter) - xr(iter-1)) / xr(iter));
    end
    
    disp([iter xr(iter) Ea(iter) xu(iter+1) xl(iter)])

    if Ea(iter) < tol | iter == maxit then
        break
    end
    iter = iter + 1;
end
root = xr(iter);
endfunction

La función de este ejemplo debe escribirse de la forma siguiente :

function f = fun1(x)
    f = 3*x-(x*x)-(5*x*x*x*x*x)
endfunction

Las variables iniciales para la función son :

x = [-5 0];
tol = 1e-3;
maxit = 100;
root = Bisection(fun1,x,tol,maxit);
disp("Raíz = ", root)

//Segundo intervalo

x = [0.5 1];
tol = 1e-3;
maxit = 100;
root = Bisection(fun1,x,tol,maxit);
disp("Raíz = ", root)

Graficando la función

Graficando la función se puede observar dos raíces entre el intervalo -1 a 1.

Gráfica

Raíces de la función

La raíz en el intervalo de -5 a 0 es :

    1.  - 2.5    1.  
    2.  - 1.25    100.  
    3.  - 0.625    100.  
    4.  - 0.9375    33.333333  
    5.  - 1.09375    14.285714  
    6.  - 1.015625    7.6923077  
    7.  - 0.9765625    4.  
    8.  - 0.9570313    2.0408163  
    9.  - 0.9472656    1.0309278  
    10.  - 0.9423828    0.5181347  
    11.  - 0.9399414    0.2597403  
    12.  - 0.9411621    0.1297017  
    13.  - 0.9417725    0.0648088  
    14.  - 0.9420776    0.0323939  
    15.  - 0.9422302    0.0161943  
    16.  - 0.9423065    0.0080965  
    17.  - 0.9423447    0.0040481  
    18.  - 0.9423256    0.0020241  
    19.  - 0.9423161    0.0010121  
    20.  - 0.9423113    0.0005060  
 root =    
  - 0.9423113

La posible raíz en el intervalo 0 a 1 es :

   1.   0.55   1.   0.55   1.
   2.   0.775   29.0323   0.775   1.
   3.   0.8875   12.6761   0.775   1.
   4.   0.83125   6.76692   0.775   0.8875
   5.   0.80313   3.50195   0.80313   0.83125
   6.   0.81719   1.72084   0.80313   0.83125
   7.   0.81016   0.86789   0.81016   0.81719
   8.   0.81367   0.43207   0.81016   0.81719
   9.   0.81191   0.2165   0.81191   0.81367
   10.   0.81279   0.10813   0.81279   0.81367
   11.   0.81323   0.05404   0.81279   0.81367
   12.   0.81301   0.02703   0.81301   0.81323
   13.   0.81312   0.01351   0.81312   0.81323
   14.   0.81318   0.00676   0.81318   0.81323
   15.   0.8132   0.00338   0.8132   0.81323
   16.   0.81322   0.00169   0.81322   0.81323
   17.   0.81323   0.00084   0.81322   0.81323

--> disp("Raz = ", root)

  "Raíz = "

   0.81323

Licencia Creative Commons
Métodos numéricos, Método de la Bisección para obtener raíces con Scilab por Marco Polo Jácome Toss se distribuye bajo una Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional.