Diferencia entre revisiones de «Método de bisección»
Deshecha la edición 37739052 de 148.214.69.90 (disc.) |
|||
Línea 98: | Línea 98: | ||
% Aproxima por el método de la bisección una raíz de la ecuación fun(x)=0 |
% Aproxima por el método de la bisección una raíz de la ecuación fun(x)=0 |
||
disp('Método de la bisección'); |
disp('Método de la bisección'); |
||
u=feval(fun,a); |
|||
v=feval(fun,b); |
|||
n=1; |
n=1; |
||
if sign(u)==sign(v) |
if sign(u)==sign(v) |
||
Línea 106: | Línea 106: | ||
while ((b-a)*0.5>tol) |
while ((b-a)*0.5>tol) |
||
c=(b+a)/2; w=feval(fun,c); |
c=(b+a)/2; w=feval(fun,c); |
||
disp([' |
disp(['n=', num2str(n)]); |
||
disp([' |
disp(['c=', num2str(c)]); |
||
disp([' |
disp(['f(c)=', num2str(w)]); |
||
if sign(u)==sign(w) |
if sign(u)==sign(w) |
||
a = c; u=w; |
a = c; u=w; |
||
Línea 114: | Línea 114: | ||
b=c; v=w; |
b=c; v=w; |
||
end |
end |
||
n=n+1; |
|||
end; |
end; |
||
x=c; |
|||
</source> |
</source> |
||
Revisión del 17:07 6 jun 2010
En matemáticas, el método de bisección es un algoritmo de búsqueda de raíces que trabaja dividiendo el intervalo a la mitad y seleccionando el subintervalo que tiene la raíz.
Introducción
Supóngase que queremos resolver la ecuación f(x) = 0 (donde f es continua. Dados dos puntos a y b tal que f(a) y f(b) tengan signos distintos, sabemos por el Teorema de Bolzano que f debe tener, al menos, una raíz en el intervalo [a, b]. El método de bisección divide el intervalo en dos, usando un tercer punto c = (a+b) / 2. En este momento, existen dos posibilidades: f(a) y f(c), ó f(c) y f(b) tienen distinto signo. El algoritmo de bisección se aplica al subintervalo donde el cambio de signo ocurre.
El método de bisección es menos eficiente que el método de Newton, pero es mucho más seguro asegurar la convergencia.
Si f es una función continua en el intervalo [a, b] y f(a)f(b) < 0, entonces este método converge a la raíz de f. De hecho, una cota del error absoluto es:
en la n-ésima iteración. La bisección converge linealmente, por lo cual es un poco lento. Sin embargo, se garantiza la convergencia si f(a) y f(b) tienen distinto signo.
Si existieran más de una raíz en el intervalo entonces el método sigue siendo convergente pero no resulta tan fácil caracterizar hacia qué raíz converge el método.
Algoritmo
Para aplicar el método consideremos tres sucesiones definidas por las siguientes relaciones:
Donde los valores iniciales vienen dados por:
Se puede probar que las tres sucesiones convergen al valor de la única raíz del intervalo:
Método de bisección en diferentes lenguajes de Programación
C
El siguiente código en lenguaje C, Permite la obtención de de las raíces de una función usando el Método de bisección:
#include<stdio.h>
#include<math.h>
// #include<conio.h> // NOTA: conio.h no es parte de ANSI C, es una libreria de C de Borland
//Funcion Que Queremos hallar
double f(double x){
return ((pow(x/3, 2))+(9)); //Esta funcion es Y=(X*X*X)/3)+9 Reemplazar por la funcion deseada ej: Y=(x*x)+(3*x)+6
}
// Funcion pausar
char pausa()
{
char c;
printf("Presiona enter para contiuar...");
c=getchar();
}
//biseccion: Retorna el valor de la funcion usando metodo de biseccion
//parametros: a= valor menor al punto
//parametros: b= valor mayor al punto
//parametros: p= el punto que deseamos encontrar
//parametros: errorDeseado = margen de error
double biseccion(double a, double b, double p, double errorDeseado){
double xr, errorAbsoluto; //xr representa el punto intermedio
printf("valor a:%f valorb:%f\n",a,b);
xr=((b+a)/2);
printf("biseccion a,b: %f\n",f(xr));
//Cambia A o B por el valor del punto dependiendo de cuales se encuentran en medio de p
if(p<xr){
b=xr;
}else{
a=xr;
}
//calcula el error relativo
errorAbsoluto=fabs(f(p)-fabs(f(xr)));
//Si el margen de error ya es valido retorna la funcion.
if (errorAbsoluto<errorDeseado){
return xr;
}else{
return biseccion(a,b, p, errorDeseado);
}
}
int main(){
printf("%f\n", biseccion(-424,146, 7, 0.02)); // introduce un rango amplio
// getch(); // NOTA: Se recomienda para pausar crear su propia funciona de caracter para continuar, o usar la pausa nativa de OS.
pausa(); // system("pause"); es otra opcion en sistemas windows.
return 0;
}
MatLab
function x = biseccion(fun,a,b,tol)
% Aproxima por el método de la bisección una raíz de la ecuación fun(x)=0
disp('Método de la bisección');
u=feval(fun,a);
v=feval(fun,b);
n=1;
if sign(u)==sign(v)
disp('Error la función debe cambiar de signo en (a,b)');
end
while ((b-a)*0.5>tol)
c=(b+a)/2; w=feval(fun,c);
disp(['n=', num2str(n)]);
disp(['c=', num2str(c)]);
disp(['f(c)=', num2str(w)]);
if sign(u)==sign(w)
a = c; u=w;
else
b=c; v=w;
end
n=n+1;
end;
x=c;
Python
# -*- coding: utf-8 -*-
from math import sin,cos,tan,asin,acos,atan,sqrt,log,exp
from math import sinh,cosh,tanh,asinh,acosh,atanh
ec=raw_input('De la funcion a resolver: ')
x1=float(input('de el extremo inferior del intervalo aproximado: '))
x2=float(input('de el extremo superior del intervalo aproximado: '))
errordeseado=input('De el error deseado: ')
def f(x):
return eval(ec)
while True:
xmed=(x1+x2)/2
if f(xmed)==0.0:
break
if (f(x1)*f(xmed))<0:
x2=xmed
else:
x1=xmed
error=abs(x2-x1)
if error<errordeseado:
break
print 'La raiz es',xmed
SciLab
El siguiente código para SciLab, Permite la obtención de de las raíces de una función usando el Método de bisección:
function x = biseccion(LaFuncion,a,b,tolerancia)
disp('Método de la bisección');
u=evstr("LaFuncion(a)");
v=evstr("LaFuncion(b)");
n=1;
disp(sign(u));
disp(sign(v));
if sign(u)==sign(v)
disp('Error la La función debe cambiar de signo en (a,b)');
end
while ((b-a)*0.5>tolerancia)
c=(b+a)/2;
w=evstr("LaFuncion(c)");
disp(['************ Paso : ', string(n), '************'] );
disp(['Valor c=', string(c)]);
disp(['f(c)=', string(w)]);
if sign(u)==sign(w)
a=c;
u=w;
else
b=c;
v=w;
end
n=n+1;
end;
disp('************* La Raiz : *************');
x=c;
endfunction;
Metodo de la Biseccion en VB.Net 2005
Public Class metodos
Dim c As Double
Dim f_a As Double
Dim f_b As Double
Dim f_c As Double
Dim er As Double
Dim reporte As String
Public i As Integer
Dim valorfuncion As New EvalEcuaciones
Public Function biseccion(ByVal a As Double, ByVal b As Double, ByVal tolerancia As Double)
f_a = valorfuncion.EvaluaEcua(frmPrincipal.txtFuncion.Text, frmPrincipal.txtX_1.Text)
f_b = valorfuncion.EvaluaEcua(frmPrincipal.txtFuncion.Text, frmPrincipal.txtX_2.Text)
If ((f_a * f_b) < 0) Then
c = (a + b) / 2
f_c = valorfuncion.EvaluaEcua(frmPrincipal.txtFuncion.Text, c)
er = Math.Abs(a - c)
reporte = CStr(i + 1) + "ª" + Chr(9) + "x= " + CStr(c) + Chr(9) + " f(x)= " + CStr(f_c) + Chr(9) + " eror= " + CStr(er) + Chr(13) + Chr(10)
i += 1
If (tolerancia <= er) Then
If ((f_c * f_a) < 0) Then
reporte += Convert.ToString(biseccion(a, c, tolerancia))
End If
If ((f_c * f_b) < 0) Then
reporte += Convert.ToString(biseccion(b, c, tolerancia))
End If
End If
End If
Return reporte
End Function
End Class
Referencia
Bibliografía
- Richard L Burden, J. Douglas Faires (2000), "Numerical Analysis, (7th Ed)", Brooks/Cole. ISBN 0-534-38216-9.