Calcular a raiz quadrada de A em C++

C

C++ dev

Membro
Boas..

tentei fazer este programa em c++, mas o ciclo não pára...alguém ajuda?

é urgente.

http://www.uploadimagens.com/upload/501e697528930d1d9944a7a3080a636c.jpg

Código: 
/*#include <stdio.h>
#include <math.h>
#include <stdlib.h>

float funcao(float valor,float x)
{
             float z;
             z=x*x-valor;
             return z;
}
             

float derivada(float valor)
{
      float y;
      y=2*valor;
      return y;
   }
   
   
float calculo(float x,float valor)
{
        float xo=valor;
         
         //while((funcao(valor,x))!=0)
         while(x*x!=valor)
         {
         x=xo-(funcao(valor,x))/(derivada(valor));
         xo=x;
         printf("%f %f\n", x,xo);
         
         }
         printf("raiz quadrada e: %f\n",x);
         
}              


main()
{
     float valor,xo,t;
     printf("Introduza o valor:\n");
     scanf("%f",&valor);
     xo=valor;
     calculo(xo,valor);
    scanf("%f", &valor);
    
    system("PAUSE");
}

*/
 
Última edição pelo moderador:
A tua função derivada faz o quê? multiplica um número por 2? o meu cálculo infinit. está enferrujado mas acho q está algo mal na tua lógica...
 
Efectivamente, há umas coisas que tens que saber sobre o método de Newton e sobre esse código:

1) Em primeiro lugar, esse código é em C, não em C++.
2) É preferível usar int main(void) a main()
3) É perigoso comparar floats com o operador == (ou !=) (no teu caso, os floats x*x e valor). Às vezes esperamos que a comparação dê resultado, mas corremos o risco de não dar.
4) O método de Newton assume sempre que existe uma margem de erro. A computação de uma raiz quadrada (ou de qualquer outra função) pelo método de Newton nunca é exacta, é sempre uma aproximação do valor real.
5) Mais detalhes no código abaixo

Código: 
#define MARGEM_DE_ERRO 0.001
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

float funcao(float valor,float x)
{
             float z;
             z=x*x-valor;
             return z;
}
             

float derivada(float valor)
{
      float y;
      y=2*valor;
      return y;
}
   
float calculo(float x,float valor)
{
        /*
        Aqui estás a dizer que x0 (a "guess inicial") é o próprio valor.
        Não faz muito sentido. Vamos supor que eu quero a raiz quadrada de 16. E agora dizem-me para adivinhar qual é.
        A minha adivinha inicial vai ser tudo menos 16. Eu, por exemplo, posso escolher x/2 (que neste caso é igual a 8) como adivinha inicial.
        É uma adivinha melhor que o 16, porque está mais perto da solução real, mas mesmo assim não é muito boa.
        Sugiro que faças alguma pesquisa no sentido de encontrar uma boa adivinha incial.
        */
        float xo=valor;
         /*
         Ciclo infinito
         */
         while(1)
         {
         x=xo-(funcao(valor,x))/(derivada(valor));
         /*
         Se módulo(x-xo) < MARGEM_DE_ERRO, então é porque a aproximação é suficientemente boa. Por isso, podemos sair do ciclo infinito.
         Para sairmos de um ciclo infinito, usamos a instrução break.
         */
         if (fabs(x-xo) < MARGEM_DE_ERRO) break;
         xo=x;
         printf("%f %f\n", x,xo);
         
         }
         return xo;
}              

int main(void)
{
     float valor,xo;
     printf("Introduza o valor:\n");
     scanf("%f", &valor);
     xo=valor;
     float raiz_quadrada_do_valor = calculo(xo,valor);
     printf("A raiz quadrada obtida foi: %f", raiz_quadrada_do_valor);
     return 0;
}
 
Mr_Miguel disse:
Efectivamente, há umas coisas que tens que saber sobre o método de Newton e sobre esse código:

1) Em primeiro lugar, esse código é em C, não em C++.
2) É preferível usar int main(void) a main()
3) É perigoso comparar floats com o operador == (ou !=) (no teu caso, os floats x*x e valor). Às vezes esperamos que a comparação dê resultado, mas corremos o risco de não dar.
4) O método de Newton assume sempre que existe uma margem de erro. A computação de uma raiz quadrada (ou de qualquer outra função) pelo método de Newton nunca é exacta, é sempre uma aproximação do valor real.
5) Mais detalhes no código abaixo

Código: 
#define MARGEM_DE_ERRO 0.001
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

float funcao(float valor,float x)
{
             float z;
             z=x*x-valor;
             return z;
}
             

float derivada(float valor)
{
      float y;
      y=2*valor;
      return y;
}
   
float calculo(float x,float valor)
{
        /*
        Aqui estás a dizer que x0 (a "guess inicial") é o próprio valor.
        Não faz muito sentido. Vamos supor que eu quero a raiz quadrada de 16. E agora dizem-me para adivinhar qual é.
        A minha adivinha inicial vai ser tudo menos 16. Eu, por exemplo, posso escolher x/2 (que neste caso é igual a 8) como adivinha inicial.
        É uma adivinha melhor que o 16, porque está mais perto da solução real, mas mesmo assim não é muito boa.
        Sugiro que faças alguma pesquisa no sentido de encontrar uma boa adivinha incial.
        */
        float xo=valor;
         /*
         Ciclo infinito
         */
         while(1)
         {
         x=xo-(funcao(valor,x))/(derivada(valor));
         /*
         Se módulo(x-xo) < MARGEM_DE_ERRO, então é porque a aproximação é suficientemente boa. Por isso, podemos sair do ciclo infinito.
         Para sairmos de um ciclo infinito, usamos a instrução break.
         */
         if (fabs(x-xo) < MARGEM_DE_ERRO) break;
         xo=x;
         printf("%f %f\n", x,xo);
         
         }
         return xo;
}              

int main(void)
{
     float valor,xo;
     printf("Introduza o valor:\n");
     scanf("%f", &valor);
     xo=valor;
     float raiz_quadrada_do_valor = calculo(xo,valor);
     printf("A raiz quadrada obtida foi: %f", raiz_quadrada_do_valor);
     return 0;
}
Clicar para expandir...

thks ;)
 
Inicie sessão ou registe-se para poder participar.
Back
Topo