Scribd Logo
Carregar

Bem-vindo(a) ao Scribd!

  • 900 visualizações

    Calculo Numerico Raizes Bisseção

    Enviado por

    Arnaldo Jr
    O documento descreve o método da bisseção para encontrar raízes de uma função. O método divide repetidamente o intervalo inicial ao meio até que a função seja aproximadamente nula dentro de uma tolerância dada. O documento fornece o fluxograma e algoritmo do método, além de um exemplo completo de sua implementação para encontrar uma raiz da função f(x)=x^3-9x+3.

    Direitos autorais:

    Attribution Non-Commercial (BY-NC)
    Baixe no formato PDF, TXT ou leia online no Scribd

    Calculo Numerico Raizes Bisseção

    Enviado por

    Arnaldo Jr
    900 visualizações4 páginas
    O documento descreve o método da bisseção para encontrar raízes de uma função. O método divide repetidamente o intervalo inicial ao meio até que a função seja aproximadamente nula dentro de uma tolerância dada. O documento fornece o fluxograma e algoritmo do método, além de um exemplo completo de sua implementação para encontrar uma raiz da função f(x)=x^3-9x+3.

    Descrição original:

    Material sobre o método da bisseção

    Direitos autorais

    © Attribution Non-Commercial (BY-NC)

    Formatos disponíveis

    PDF, TXT ou leia online no Scribd

    Você considera este documento útil?

    Este conteúdo é inapropriado?

    O documento descreve o método da bisseção para encontrar raízes de uma função. O método divide repetidamente o intervalo inicial ao meio até que a função seja aproximadamente nula dentro de uma tolerância dada. O documento fornece o fluxograma e algoritmo do método, além de um exemplo completo de sua implementação para encontrar uma raiz da função f(x)=x^3-9x+3.

    Direitos autorais:

    Attribution Non-Commercial (BY-NC)
    Baixe no formato PDF, TXT ou leia online no Scribd
    Fazer download em pdf ou txt
    900 visualizações4 páginas

    Calculo Numerico Raizes Bisseção

    Enviado por

    Arnaldo Jr
    O documento descreve o método da bisseção para encontrar raízes de uma função. O método divide repetidamente o intervalo inicial ao meio até que a função seja aproximadamente nula dentro de uma tolerância dada. O documento fornece o fluxograma e algoritmo do método, além de um exemplo completo de sua implementação para encontrar uma raiz da função f(x)=x^3-9x+3.

    Direitos autorais:

    Attribution Non-Commercial (BY-NC)
    Baixe no formato PDF, TXT ou leia online no Scribd
    Fazer download em pdf ou txt
    de 4

    Numérico

    Willian de Araujo Rosa


    www.profwillian.com

    Método da Bisseção
    O Método da Bisseção determina uma raiz x de uma função f(x) num intervalo [xa,xb]   onde f(xa)*f(xb)<0. A
    idéia é diminuir o intervalo através de repetidas divisões ao meio do intervalo [xa,xb], de tal forma que o valor de xa
    tenda ao valor de xb, ou seja, que a raiz x  xa  xb e que a função f(x) seja aproximadamente nula dentro de uma
    certa tolerância.
    Fluxograma Algoritmo
    início início algoritmo

    declare i, Nmax numérico


    declare Xa, Xb, Xm,  numérico
    i0 i 0

    leia Xa, Xb, , Nmax


    Xa, Xb faça
    , Nmax Xm(Xa+Xb)/2
    Se f(Xa)*f(Xm)<0
    então XbXm
    senão XaXm
    fim Se
    ii+1
    enquanto |f(Xm)|> e i<Nmax

    escreva Xm, i
    Xm(Xa+Xb)/2
    fim algoritmo

    Programa C++
    {
    sim int i, Nmax;
    f(Xa)*f(Xm)<0 XbXm double Xa,Xb,Xm,Epsilon;
    ?
    i=0;

    Xa=StrToFloat(EditXa->Text);
    não Xb=StrToFloat(EditXb->Text);
    Epsilon=StrToFloat(EditEpsilon->Text);
    Nmax=StrToInt(EditNmax->Text);
    XaXm
    do
    {
    Xm=(Xa+Xb)/2;
    if (f(Xa)*f(Xm)<0)
    ii+1 {Xb=Xm;}
    else
    {Xa=Xm;}
    i++;
    } while ((fabs(f(Xm))>Epsilon)&&(i<Nmax));

    sim Memo1->Lines->Append(FloatToStr(Xm)
    |f(Xm)|> + " : " + IntToStr(i));
    e i<Nmax }
    ?
    Append()....... Método que adiciona um texto (string) ao objeto;
    não StrToFloat()..Função que converte um texto (string) em número (float);
    StrToInt()..... Função que converte um texto (string) em número (int);
    IntToStr()..... Função que converte um número (int) em texto (string);
    Xm, i FloatToStr()..Função que converte um número (float) em número (string);
    fabs ().............Função que retorna o módulo do argumento;

    fim

    1
    Vamos implementar o programa. Siga os passos abaixo:
    1- Comece gravando (Save All) . Crie uma pasta com o nome Bissecao e após abri-la, grave a unidade como
    UnitBissecao.h e grave o projeto como ProjectBissecao. . Grave a cada alteração significativa do código do programa;
    2- desenhe o formulário abaixo:

    3- altere a propriedade Caption dos componentes int i, Nmax;


    double Xa,Xb,Xm,Epsilon;
    Label1, Label 2, Label 3 e Label 4 para Xa, Xb,  e Nmax, Memo1->Clear();
    respectivamente. Coloque mais um Label com Caption i=0;
    “Método da Bisseção”;
    4- altere a propriedade Name dos componentes Edit1, Xa=StrToFloat(EditXa->Text);
    Xb=StrToFloat(EditXb->Text);
    Edit2, Edit3 e Edit4 para EditXa, EditXb, EditEpsilon e
    Epsilon=StrToFloat(EditEpsilon->Text);
    EditNmax, respectivamente; Nmax=StrToInt(EditNmax->Text);
    5- altere a propriedade Text dos componentes EditXa,
    EditXb, EditEpsilon e EditNmax para 0; 0,5; 0,001 e 50, do
    respectivamente; {
    Xm=(Xa+Xb)/2;
    6- altere a propriedade Caption do componente Button1 if (f(Xa)*f(Xm)<0)
    para Calcula; {Xb=Xm;}
    else
    7- limpe a propriedade Lines do componente Memo1; {Xa=Xm;}
    i++;
    8- digite o código, visto ao lado, no evento OnClick do Memo1->Lines->Append(FloatToStr(Xm));
    componente Button (basta dar um clique duplo à direita } while ((fabs(f(Xm))>Epsilon)&&
    do evento Onclick). Algumas linhas foram modificadas (i<Nmax));
    e/ou acrescentadas;
    Memo1->Lines->Append("|f(Xm)|= " +
    9- acrescente a linha #include <math.h> logo após a FloatToStr(fabs(f(Xm))));
    linha #include <vcl.h> Memo1->Lines->Append("i= "+IntToStr(i));
    10- acrescente o código da função f(x) logo após a linha double f(double x)
    #pragma resource "*.dfm" {
    return x*x*x-9*x+3;
    11- grave e execute o programa . }

    2
    Um exemplo:
    Vamos encontrar uma raiz da função: f ( x )  x 3  9 x  3 utilizando o Método da Bisseção. Adotaremos uma
    tolerância de =0,001 e um número máximo de iterações Nmax=50.

    Solução: Podemos começar traçando o gráfico da função:

    claramente vemos que existe uma raiz no intervalo [-3,5 ; -3,0], uma segunda raiz no intervalo [0 ; 0,5] e uma
    terceira raiz no intervalo [2,5 ; 3].

    Vamos adotar o intervalo [0,0 ; 0,5], portanto, para a iteração i=1 temos:
    xa  0 ; x b  0,5
    observem o algoritmo do método. O próximo passo é dividir o intervalo ao meio:
    x a  x b 0  0 ,5 >
    xm    0,25 f ( x m )  f (0,25)  0,765625
    2 2
    Agora temos dois intervalos. O primeiro é [0 ; 0,25] e o segundo é [0,25 ; 0,5]. Vamos verificar se a raiz se encontra no
    primeiro intervalo fazendo:
    f ( x a ).f ( x m )  f (0).f (0,25)  0 3  9.0  3
    . 0,25 3  9.0,25  3 2,296875 0
    Como o produto foi positivo, o intervalo onde se encontra a raiz não é [0 ; 0,25] e sim [0,25 ; 0,5].
    Devemos continuar já que f (x m )   e que não ultrapassamos o número máximo de iterações Nmax.

    Vamos trabalhar, agora, com o intervalo [0,25 ; 0,5], portanto, para a iteração i=2 temos:
    x a  0,25 ; x b  0,5
    O próximo passo é dividir o intervalo ao meio:
    x m  0,375 f ( x m )  f (0,375)  0,32226562 5 >
    Agora temos dois intervalos. O primeiro é [0,25 ; 0,375] e o segundo é [0,375 ; 0,5]. Vamos verificar se a raiz se encontra no
    primeiro intervalo fazendo:
    f ( x a ).f ( x m )  -0,246734619140625 0
    Como o produto foi negativo, o intervalo onde se encontra a raiz é [0,25 ; 0,375] e não [0,375 ; 0,5].
    Devemos continuar já que f (x m )   e que não ultrapassamos o número máximo de iterações Nmax.

    Vamos trabalhar, agora, com o intervalo [0,25 ; 0,375] portanto, para a iteração i=3 temos:
    x m  0,3125 f ( x m )  f (0,3125)  0,21801757 8125 >
    f ( x a ).f ( x m )  0,16691970 8251953 0
    Como o produto foi positivo, o intervalo onde se encontra a raiz não é [0,25 ; 0,3125] e sim [0,3125 ; 0,375].
    Devemos continuar já que f (x m )   e que não ultrapassamos o número máximo de iterações Nmax.

    3
    Vamos trabalhar, agora, com o intervalo [0,3125 ; 0,375], portanto, para a iteração i=4 temos:
    x m  0,34375 f ( x m )  f (0,34375)  0,05313110 3515625 >
    f ( x a ).f ( x m )  -0,0115835145115852 0
    Como o produto foi negativo, o intervalo onde se encontra a raiz é [0, 3125; 0,34375]
    Devemos continuar já que f (x m )   e que não ultrapassamos o número máximo de iterações Nmax.

    Vamos trabalhar, agora, com o intervalo [0, 3125; 0,34375], portanto, para a iteração i=5 temos:
    x m  0,328125 f ( x m )  f (0,328125)  0,08220291 13769531 >
    f ( x a ).f ( x m )  0,01792167 96532273 0
    Como o produto foi positivo, o intervalo onde se encontra a raiz é [0,328125; 0,34375].
    Devemos continuar já que f (x m )   e que não ultrapassamos o número máximo de iterações Nmax.

    O intervalo é [0,328125; 0,34375] para a iteração i=6 < Nmax, temos:


    x m  0,3359375 f ( x m )  f (0,3359375)  0,01447439 19372559 >
    f ( x a ).f ( x m )  0,00118983 715765353 0
    Como o produto foi positivo, o intervalo onde se encontra a raiz é [0,3359375; 0,34375].

    O intervalo é [0,3359375; 0,34375] para a iteração i=7 < Nmax, temos:


    x m  0,33984375 f ( x m )  f (0,33984375 )  0,01934391 26014709 >
    f ( x a ).f ( x m )  -0,00027999137259371 3 0
    Como o produto foi negativo, o intervalo onde se encontra a raiz é [0,3359375; 0,33984375].

    O intervalo é [0,3359375; 0,33984375] para a iteração i=8 < Nmax, temos:


    x m  0,33789062 5 f ( x m )  f (0,33789062 5 )  0,00243862 718343735 >

    f ( x a ).f ( x m )  -3,52976456419185 x10 -5 0


    Como o produto foi negativo, o intervalo onde se encontra a raiz é [0,3359375; 0,337890625].

    O intervalo é [0,3359375; 0,337890625] para a iteração i=9 < Nmax, temos:


    x m  0,33691406 25 f ( x m )  f (0,33691406 25)  0,00601691 845804453 >

    f ( x a ).f ( x m )  8,70912360 162457 x10 -5


    0
    Como o produto foi positivo, o intervalo onde se encontra a raiz é [0,3369140625; 0,337890625].

    O intervalo é [0,3369140625; 0,337890625] para a iteração i=10 < Nmax, temos:


    x m  0,33740234 375 f ( x m )  f (0,33740234 375)  0,00178890 430834144 >

    f ( x a ).f ( x m )  1,0763691352535 x10 -5


    0
    Como o produto foi positivo, o intervalo onde se encontra a raiz é [0,33740234375; 0,337890625].

    O intervalo é [0,33740234375; 0,337890625] para a iteração i=11 < Nmax, temos:


    x m  0,33764648 4375 f ( x m )  f (0,33764648 4375)  0,00032492 1813444234 <

    Como f ( x m )   , a raiz é x  x m  0,33764648 4375


    Tabela Resumo
    i Xa Xb Xm f(Xm) f(Xa)*f(Xm)
    1 0 0,5 0,25 0,765625 2,296875
    2 0,25 0,5 0,375 -0,322265625 -0,246734619140625
    3 0,25 0,375 0,3125 0,218017578125 0,166919708251953
    4 0,3125 0,375 0,34375 -0,053131103515625 -0,0115835145115852
    5 0,3125 0,34375 0,328125 0,0822029113769531 0,0179216796532273
    6 0,328125 0,34375 0,3359375 0,0144743919372559 0,00118983715765353
    7 0,3359375 0,34375 0,33984375 -0,0193439126014709 -0,000279991372593713
    8 0,3359375 0,33984375 0,337890625 -0,00243862718343735 -3,52976456419185E-5
    9 0,3359375 0,337890625 0,3369140625 0,00601691845804453 8,70912360162457E-5
    10 0,3369140625 0,337890625 0,33740234375 0,00178890430834144 1,0763691352535E-5
    11 0,33740234375 0,337890625 0,337646484375 -0,000324921813444234 -5,81254031944506E-7

    Exercício: Siga o roteiro acima e encontre a raiz no intervalo [2,5 ; 3]. Sugestão: altere o programa para que a
    saída de resultados se assemelhe à tabela resumo acima.

    Você também pode gostar