CRUZ BARTOLON

DIAZ CANCINO
MENDEZ PEREZ
FIC/UNACH
PROGRAMACION
TRABAJO POR EQUIPO

METODO DE BISECCION

Si f es una función continua sobre el intervalo [a;b] y si f(a).f(b)<0, entonces f

debe tener un cero en (a;b). Dado que f(a).f(b)<0, la función cambia de signo en el
intervalo [a;b] y, por lo tanto, tiene por lo menos un cero en el intervalo. Ésta es
una consecuencia del teorema del valor intermedio para funciones continuas.
El método de bisección explota esta idea ya que los extremos del intervalo se
van a ir acercando sistemáticamente hasta obtener un intervalo de longitud
suficientemente pequeña en el que se localiza un cero. El proceso de decisión
para subdividir el intervalo consiste en tomar el punto medio del intervalo c =
(a+b)/2 y luego analizar las tres posibilidades que pueden darse:
 Si f(a) y f(c) tienen signos opuestos, entonces hay un cero en [a;c].
 Si f(c) y f(b) tienen signos opuestos, entonces hay un cero en [c;b].
 Si f(c)=0, entonces c es un cero.
Si ocurre la primera opción, o bien la segunda, entonces se ha encontrado un
intervalo de mitad de ancho que el original que contiene una raíz. Para continuar el
proceso, se renombra el nuevo intervalo más pequeño como [a;b] y se repite el
proceso hasta que el intervalo sea tan pequeño como se desee. Puesto que el
proceso de bisección genera una sucesión de intervalos encajados, con sus
correspondientes puntos medios, se usará la siguiente notación para tener registro
de los detalles del proceso:
 [a1;b1] es el intervalo de partida y c1=(a1+b1)/2 es su punto medio.
 [a2;b2] es el segundo intervalo y c 2=(a2+b2)/2 es su punto medio; el
intervalo [a2;b2] es la mitad de ancho que [a1;b1].
 Después de llegar al intervalo [a n;bn], en el que también se localiza un
cero y cuyo punto medio está dado por c n=(an+bn)/2, se construye el
intervalo [an+1;bn+1], en el que también se localiza un cero, y que mide la
mitad que [an;bn]
 Análisis del error

Con el objeto de analizar el método de la bisección, se llamará [a i;bi], con i =

1, 2, 3, …, a los intervalos que surgen en el proceso. Se pueden hacer las
siguientes observaciones sobre estos números:
 a1≤a2≤...≤an≤b1 la sucesión {an} converge porque es creciente y
está acotada superiormente.
 b1≥b2≥...≥bn≥a1  la sucesión {bn} converge porque es
decreciente y está acotada inferiormente.
 bn+1-an+1 = (bn-an)/2, n≥1 (bn-an)= (b1-a1)/2(n-1) n≥1. (*)
Si se aplica límite a esta última igualdad se obtiene:

Entonces, resulta que los límites de ambas sucesiones son iguales:

Tomando el límite en la desigualdad f(a n).f(bn) ≤ 0, encontramos que [f(r)] 2 ≤

0, por lo tanto, debe ser f(r) = 0.

Se llamará [an,bn] al intervalo obtenido en el paso n-1. Si en este momento se

detiene el proceso, la raíz se encontrará en ese intervalo. En este paso, la mejor
aproximación será el punto medio del intervalo,

El error en el paso n es:

(1) Dado que r (la raíz buscada) está en una de las dos mitades del intervalo
[an, bn], la distancia del punto medio del intervalo a r debe ser menor o igual
que la mitad de la longitud del intervalo.
(2) Por la igualdad demostrada en (*)
 Ventajas y desventajas

Una gran ventaja de este método es que siempre converge para funciones
continuas f(x). Además, proporciona el tamaño exacto del intervalo en cada
iteración (en ausencia de errores de redondeo). Para aclarar esto, se puede
observar que en este método después de cada iteración el tamaño del intervalo se
reduce a la mitad; después de n iteraciones, el intervalo original se habrá reducido
2n veces. Por lo anterior, si el intervalo original es de tamaño M y el criterio de
convergencia aplicado al valor absoluto de la diferencia de dos aproximaciones
sucesivas es ε, se puede saber de antemano el número de iteraciones que se
requieren:

No obstante, una de las grandes desventajas que presenta este método es

su velocidad de convergencia, la cual es bastante baja.

Orden de convergencia

Un algoritmo converge linealmente si existe una constante positiva K<1 tal

que para todo n suficientemente grande. Tal K recibe el nombre de factor de

convergencia.
Como se puede observar, el método de la bisección es un método lineal
debido a que el error en la iteración siguiente es la mitad del error de la iteración
previa solamente.
 Aproximación inicial y criterios de convergencia

El método de la bisección depende de la determinación de un intervalo inicial

[a;b] en el que f(a) y f(b) tengan distinto signo. Una vez encontrado este intervalo,
no importa lo grande que sea, se podrá empezar a iterar hasta que se encuentre
una raíz con la precisión deseada. Por esta razón, se dice que este método es
globalmente convergente.
Sin embargo, si f(x)=0 tiene varias raíces en [a;b], entonces se debe
encontrar un intervalo de partida distinto para hallar cada raíz y no suele ser fácil
hallar estos intervalos más pequeños en los que el signo de f(x) cambia.
En la sección Conceptos básicos se encuentran otros métodos que
requieren, como garantía de su convergencia, que el punto inicial esté cerca de la
raíz buscada, por lo que se dice que son localmente convergentes. Estos métodos
suelen converger más rápidamente que los métodos globales, de manera que
existen algoritmos híbridos que empiezan con un método de convergencia global
y, cuando las aproximaciones obtenidas en las distintas iteraciones se hallan cerca
de la raíz, cambian a un método de convergencia local.

Comprobación de la convergencia

Es imprescindible establecer un criterio de parada para que el algoritmo

detenga las iteraciones cuando haya obtenido una aproximación suficientemente
precisa
Como el objetivo es resolver f(x)=0, el valor xn debería verificar que:

Así, el proceso iterativo producirá puntos P i= (xi; f(xi)) hasta que el último
punto Pn se encuentre en la banda horizontal comprendida entre las rectas de
ecuaciones y=ε e y=-ε.
 Otro criterio de parada involucra las abscisas. Se trata de determinar si la
sucesión {xn} converge y, para ello, se dibujan dos rectas verticales de ecuaciones
x=P+β y x=P-β a cada lado de x=P. De esta manera, el proceso se detendrá
cuando Pn está entre ambas rectas.
A continuación mostramos la interfaz del programa, para luego la programación en
builder C++, para poder encontrar lo raíz de una función f(x) cualquiera.

Presionamos el botón de entrada i directamente nos manda a la siguiente interfaz.

A continuación un ejemplo del interfaz del programa con un polinomio (x^4+3x^3 –

2 = 0).
Después de haber realizado varias iteraciones llegamos a la raíz aproximada
como se muestra en la interfaz.

Y para estar seguros de que es una raíz del polinomio se muestra en la siguiente
grafica que efectivamente existe una aproximación a la raíz obtenida.
Esta programación nos ayudara a encontrar una sola raíz real de un polinomio en
caso de que exista y para ya no seguir haciendo laboriosos procedimientos en
esta interfaz es muy útil porque solo introducimos el polinomio y después de unas
cuantas iteraciones nos dice la raíz. En caso de que este método no funcione hay
muchos tipos de métodos para encontrar una raíz de un polinomio.
A continuación la programación de la interfaz del método de Bisección.

Código de programación:
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{
Form2->Show();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{
Close();
}
//---------------------------------------------------------------------------

Còdigo de programaciòn:
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h"
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
#include <math.h>
double a,b,c,d,e,p,q,Fx1,Fx2,Fx3,Fx4,Fx5,Fxl,Fr,Fxm,r,prod, i=1,x,h,t,j,l,m,
inicio,k,y,por;

//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm2::Button1Click(TObject *Sender)

{

//hablitando grafica

Button1->Enabled=true;

a=Edit1->Text.ToDouble();
b=Edit2->Text.ToDouble();
c=Edit3->Text.ToDouble();
d=Edit4->Text.ToDouble();
e=Edit5->Text.ToDouble();
p=Edit6->Text.ToDouble();
q=Edit7->Text.ToDouble();
h=Edit8->Text.ToDouble();
t=Edit9->Text.ToDouble();
j=Edit10->Text.ToDouble();

Fx1=a*(pow(p,4))+b*(pow(p,3))+c*(pow(p,2))+d*p+e;
Edit11->Text=AnsiString(Fx1);
Fx2=a*(pow(q,4))+b*(pow(q,3))+c*(pow(q,2))+d*q+e;
Edit12->Text=AnsiString(Fx2);
Fx3=a*(pow(h,4))+ b*(pow(h,3))+c*(pow(h,2))+d*h+e;
Edit13->Text=AnsiString(Fx3);
Fx4=a*(pow(t,4))+b*(pow(t,3))+c*(pow(t,2))+d*t+e;
Edit14->Text=AnsiString(Fx4);
Fx5=a*(pow(j,4))+b*(pow(j,3))+c*(pow(j,2))+d*j+e;
Edit15->Text=AnsiString(Fx5);

}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{

l=Edit16->Text.ToDouble();
Fxl=a*(pow(l,4))+b*(pow(l,3))+c*(pow(l,2))+d*l+e;

m=Edit17->Text.ToDouble();
Fxm=a*(pow(m,4))+b*(pow(m,3))+c*(pow(m,2))+d*m+e;

r=(l+m)/2;
Edit18->Text=AnsiString(r);
Fr=a*(pow(r,4))+b*(pow(r,3))+c*(pow(r,2))+d*r+e;
Label15->Caption=AnsiString(r);
Label13->Caption=AnsiString(i);
i++;

}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button3Click(TObject *Sender)
{

prod=Fxl*Fr;
Edit19->Text=AnsiString(prod);
por=((m-l)/m)*100;
Edit20->Text=AnsiString(por);
Label16->Caption="Eso es todo Margaritos...!!!";
if(prod >0 ){
Edit16->Text="";
Edit16->Text=AnsiString(r);
}
if(prod <0){
Edit17->Text="";
Edit17->Text=AnsiString(r);
}

}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button6Click(TObject *Sender)
{
Form3->Show();
Form3->Canvas->Pen->Color=clGreen;
Form3->Canvas->Pen->Width=2;
Form3->Canvas->PenPos=TPoint(0,350);
Form3->Canvas->LineTo(1300,350);
Form3->Canvas->PenPos=TPoint(650,0);
Form3->Canvas->LineTo(650,700);
for(x=-30;x<=30;x++){
Form3->Canvas->PenPos=TPoint(650+x*10,355);
Form3->Canvas->LineTo(650+x*10,345);

for(y=-30;y<=30; y++){
Form3->Canvas->PenPos=TPoint(645,350+y*10);
Form3->Canvas->LineTo(655,350+y*10);
}
Form3->Canvas->Pen->Color=clYellow;
Form3->Canvas->Pen->Width=2;
x=-650;
Form3->Canvas->PenPos=TPoint(650+x,350-
10*(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
for(x=-650;x<=650;x++){
Form3->Canvas->LineTo(650+x,350-
10*(a*pow(x/10,4)+b*pow(x/10,3)+c*pow(x/10,2)+d*x/10+e));
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button4Click(TObject *Sender)
{

a=0;
b=0;
c=0;
d=0;
e=0;
p=0;
q=0;
r=0;
h=0;
t=0;
j=0;
Fx1=0;
Fx2=0;
Fx3=0;
Fx4=0;
Fx5=0;
Fr=0;
i=1;

Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Edit4->Text="";
Edit5->Text="";
Edit6->Text="";
Edit7->Text="";
Edit8->Text="";
Edit9->Text="";
Edit10->Text="";
Edit11->Text="";
Edit12->Text="";
Edit13->Text="";
Edit14->Text="";
Edit15->Text="";
Edit16->Text="";
Edit17->Text="";
Edit18->Text="";
Edit19->Text="";
Edit20->Text="";

Label13->Caption="";
Label15->Caption="";
Label16->Caption="";
}
//---------------------------------------------------------------------------
void __fastcall TForm2::Button5Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------

Còdigo de programaciòn:
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm3 *Form3;
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm3::Button1Click(TObject *Sender)

{
Close();
}
//---------------------------------------------------------------------------