[Resolvido]Ajuda raiz quadrada usando iteração.

Boa tarde galera, sou iniciante na programação, se alguém puder dar um ajudinha ai na lógica desde exercícios, pois já tentei de várias maneiras e não saio do lugar, grato desde já.


Este é o Exercício:

Um método iterativo para calcular a raiz quadrada é o seguinte: primeiro, buscamos um limite inferior, ou seja, um número cujo quadrado é menor do que x. Por exemplo, se x=20, o número poderia ser 3, porque 32=9 (menor que 20). Achamos então um limite superior, um número cujo quadrado é maior que x – no exemplo, o limite superior poderia ser 10, já que 102=100 (maior que 20). Sabemos então que a raiz de 20 está entre 3 e 10. Tomamos então um valor que esteja entre estes limites – por exemplo, 6.5. Verificamos se o quadrado deste valor é maior ou menor que x. Como 6.52=42.25, que é maior que x, sabemos que a raiz de x deve ser menor que 6.5. Atualizamos os limites e repetimos a operação, até encontrarmos um número cujo quadrado seja suficientemente próximo de x. A tabela abaixo mostra algumas iterações do algoritmo para x=20, escolhendo como limites iniciais 3 e 10, e escolhendo como palpite a média dos limites.

Iteração Limite inferior Limite superior Palpite Quadrado
0 3 10 6.5 42.25
1 3 6.5 4.75 22.56
2 3 4.75 3.88 10.05
3 3.88 4.75 4.32 18.66
4 4.32 4.75 4.54 20.61
5 4.32 4.54 4.43 19.63
6 4.43 4.54 4.49 20.16
7 4.43 4.49 4.46 19.89
8 4.46 4.49 4.48 20.07

Note que outros métodos poderiam ter sido escolhidos para determinar os limites iniciais e o palpite – no exemplo acima, o limite inferior poderia ser qualquer valor menor que √x, o limite superior poderia ser qualquer valor maior que √x, e o palpite poderia ser qualquer valor entre o limite inferior e o superior.

Note também que o quadrado do palpite tende a se aproximar cada vez mais da solução correta, enquanto os limites ficam cada vez mais próximos entre si. Chamamos isto de convergência. Existem métodos para se aproximar a raiz quadrada que convergem mais rápido que este, mas este método é intuitivo, e qualquer pessoa com conhecimentos elementares de matemática pode compreender seu mecanismo (e, se a precisão exigida for baixa, reproduzí-lo usando papel e caneta).
==================================================================================
O último que eu fiz, está aqui em baixo,grato desde já.

#include
#include

int main()
{
double x, cont,cont1,limite_inferior, limite_superior,palpite,teste,erro;

printf("digite x: \n");
scanf("%lf", &x);

printf("Digite erro: \n");
scanf("%lf", &erro);

cont=x;

while(cont*cont>x) \\ Para encontrar o limite inferior.
{
cont --;
}
limite_inferior= cont;

cont1=cont;

while(cont1*cont1 {
cont1 ++;
}
limite_superior=cont1;

palpite=(limite_superior+limite_inferior)/2;

while(teste {

if(palpite*palpite>x)
{
while(palpite*palpite>x)
{

limite_superior=palpite;
palpite=(limite_superior+limite_inferior)/2;
teste=(palpite*palpite)-x;
}
}


else
{
while(palpite*palpite {

limite_inferior=palpite;
palpite=(limite_superior+limite_inferior)/2;
teste=(palpite*palpite)-x;
}
}
}




printf("O valor do LS eh %lf\n", limite_superior);
printf("O valor da raiz eh %lf\n", palpite);
printf("O valor do LI eh %lf\n",limite_inferior);

return 0;
}

Olá,
Pelo que entendi você deseja encontrar a raiz quadrada de um número
inteiro não-quadrado perfeito...
Antes de colocar o código, escreverei como montei a lógica do programa =)
Então vamos a lógica ...

Passo 1 - Determinar os limites
Podemos observar que a raiz de um numero inteiro,não quadrado perfeito,
está entre a raiz exata imediatamente anterior e a raiz exata
imediatamente posterior:

√7 está entre  √4 e √9 ou seja,  √7 esta entre 2 e 3
√54 está entre  7 e 8  ou seja,  √54 esta entre √49 e  √64

Sabendo disso, para encontrar o limite inferior de  √7, por exemplo,
comecei subtraindo 1 do numero e verificando se a raiz é exata,
caso seja exata o limite inferior será o resultado desta raiz, caso
contrario continuo decrementando 1 do numero até que se encontre
uma raiz exata.
Para encontrar o limite superior usei a metodologia inversa, ou seja,
somando 1 ao numero, e verificando se sua raiz é exata, caso não seja,
continuo somando 1, até que se encontre um que tenha a raiz exata e
por conseguinte encontrar o limite superior.

Passo 2 -  Encontrar a Raiz
Tendo os limites extremos, eu partir da premissa de que a
raiz seria =  0.1+limiteInferior então testei sucessivamente o quadrado desta raiz até que ela fosse aproximadamente igual ao numero.

Segue o código...

#include
#include
#include

int lmtInferior(int x)
{
   int num = --x, exata=0;
   float inferior, teste;

   /*teste para econtrar a raiz exata anterior a x*/
   while(!exata)
   {
        inferior = sqrt(num);
        teste = inferior - (int)inferior; /*teste para verificar se essa raiz é exata*/
        if(teste > 0) /*caso a raiz não seja exata testa o numero
                      anterior e continua a procura*/
           num--;
        else  /*caso seja exata, termina o laço*/
           exata = 1;        
   }

  return inferior;    
}

int lmtSuperior(int x)
{
   int num = ++x, exata=0;
   float superior, teste;

   while(!exata)
   {
        superior = sqrt(num);
        teste = superior - (int)superior;
        if(teste > 0)
           num++;
        else
           exata = 1;        
   }
  return superior;    
}

float encontraRaiz(int inferior, int superior, int num)
{
     float raiz = inferior + 0.1;
     float teste = raiz * raiz;

     
     while(teste < num)
     {
          raiz += 0.1;
          teste = raiz * raiz;
                           
     }
   raiz -= 0.1;

   return raiz;
}

int
main(void)
{
  int num, inferior, superior;
  float raiz;
 
  printf("Qual raiz nao exata deseja encontrar?\n");
  scanf("%d", &num);
 
  printf("Limite Inferior = %d\n", inferior = lmtInferior(num));
  printf("Limite Superior = %d\n", superior = lmtSuperior(num));  

  printf("Raiz eh aproximadamente  %.1f\n", raiz = encontraRaiz(inferior, superior, num));

  printf("\n");
  system("pause");
  return 0;
}

Enfim, espero ter ajudado um pouco ^^