web-dev-qa-db-fra.com

Trouver la racine carrée sans utiliser la fonction sqrt?

Je cherchais l'algorithme pour trouver la racine carrée sans utiliser la fonction sqrt, puis j'ai essayé de mettre en programmation. Je me retrouve avec ce code de travail en C++

    #include <iostream>
    using namespace std;

    double SqrtNumber(double num)
    {
             double lower_bound=0; 
             double upper_bound=num;
             double temp=0;                    /* ek edited this line */

             int nCount = 50;

        while(nCount != 0)
        {
               temp=(lower_bound+upper_bound)/2;
               if(temp*temp==num) 
               {
                       return temp;
               }
               else if(temp*temp > num)

               {
                       upper_bound = temp;
               }
               else
               {
                       lower_bound = temp;
               }
        nCount--;
     }
        return temp;
     }

     int main()
     {
     double num;
     cout<<"Enter the number\n";
     cin>>num;

     if(num < 0)
     {
     cout<<"Error: Negative number!";
     return 0;
     }

     cout<<"Square roots are: +"<<sqrtnum(num) and <<" and -"<<sqrtnum(num);
     return 0;
     }

Maintenant, le problème est d'initialiser le nombre d'itérations nCount dans la déclaration (ici, c'est 50). Par exemple, pour trouver la racine carrée de 36, cela prend 22 itérations, donc pas de problème alors que trouver la racine carrée de 15625 prend plus de 50 itérations, donc cela retournerait la valeur de temp après 50 itérations. Veuillez donner une solution pour cela.

c++algorithmmathsqrt
16
Arun Pandey

Il existe un meilleur algorithme, qui nécessite au plus 6 itérations pour converger vers une précision maximale pour les nombres doubles:

#include <math.h>

double sqrt(double x) {
    if (x <= 0)
        return 0;       // if negative number throw an exception?
    int exp = 0;
    x = frexp(x, &exp); // extract binary exponent from x
    if (exp & 1) {      // we want exponent to be even
        exp--;
        x *= 2;
    }
    double y = (1+x)/2; // first approximation
    double z = 0;
    while (y != z) {    // yes, we CAN compare doubles here!
        z = y;
        y = (y + x/y) / 2;
    }
    return ldexp(y, exp/2); // multiply answer by 2^(exp/2)
}

L'algorithme commence par 1 comme première approximation de la valeur de racine carrée. Ensuite, à chaque étape, il améliore l'approximation suivante en prenant la moyenne entre la valeur actuelle y et x/y. Si y = sqrt(x), ce sera la même chose. Si y> sqrt(x), alors x/y <sqrt(x) d'environ le même montant. En d'autres termes, il convergera très rapidement.

UPDATE : Pour accélérer la convergence sur de très grands ou très petits nombres, changé la fonction sqrt() pour extraire l'exposant binaire et calculer la racine carrée à partir du nombre dans la plage [1, 4). Il a maintenant besoin de frexp() de <math.h> Pour obtenir l'exposant binaire, mais il est possible d'obtenir cet exposant en extrayant des bits du format numérique IEEE-754 sans utiliser frexp().

33
mvp

Pourquoi ne pas essayer d'utiliser la méthode babylonienne pour trouver une racine carrée.

Voici mon code pour cela:

double sqrt(double number)
{
    double error = 0.00001; //define the precision of your result
    double s = number;

    while ((s - number / s) > error) //loop until precision satisfied 
    {
        s = (s + number / s) / 2;
    }
    return s;
}

Bonne chance!

6
Newskooler

Supprimez complètement votre nCount (car il y a des racines pour lesquelles cet algorithme prendra plusieurs itérations).

double SqrtNumber(double num)
{
    double lower_bound=0; 
    double upper_bound=num;
    double temp=0;

    while(fabs(num - (temp * temp)) > SOME_SMALL_VALUE)
    {
           temp = (lower_bound+upper_bound)/2;
           if (temp*temp >= num)
           {
                   upper_bound = temp;
           }
           else
           {
                   lower_bound = temp;
           }
    }
    return temp;
 }
2
Zac Howland

si vous avez besoin de trouver la racine carrée sans utiliser sqrt(), utilisez root=pow(x,0.5).

Où x est la valeur dont vous devez trouver la racine carrée.

1
Mani Kant

Comme j'ai trouvé cette question est ancienne et a beaucoup de réponses mais j'ai une réponse qui est simple et fonctionne très bien ..

#define EPSILON 0.0000001 // least minimum value for comparison
double SquareRoot(double _val) {
    double low = 0; 
    double high = _val;
    double mid = 0; 

    while (high - low > EPSILON) {
            mid = low + (high - low) / 2; // finding mid value
            if (mid*mid > _val) {
                high = mid;
            } else {
                low = mid;
            }    
    }   
    return mid;
}

J'espère que cela sera utile pour les futurs utilisateurs.

1
Himanshu

Il s'agit d'une approche récursive très simple.

double mySqrt(double v, double test) {
    if (abs(test * test - v) < 0.0001) {
        return test;
    }

    double highOrLow = v / test;
    return mySqrt(v, (test + highOrLow) / 2.0);
}
double mySqrt(double v) {
    return mySqrt(v, v/2.0);
}
0
Cameron Monks
//long division method.
#include<iostream>
using namespace std;
int main() {
int n, i = 1, divisor, dividend, j = 1, digit;
cin >> n;
while (i * i < n) {
    i = i + 1;
}
i = i - 1;
cout << i << '.';

divisor  = 2 * i;
dividend = n - (i * i );
while( j <= 5) {
    dividend = dividend * 100;
    digit = 0;
    while ((divisor * 10 + digit) * digit < dividend) {
        digit = digit + 1;
    }
    digit = digit  - 1;
    cout << digit;
    dividend = dividend - ((divisor * 10 + digit) * digit);
    divisor = divisor * 10 + 2*digit;
    j = j + 1;
}
cout << endl;
return 0;
}
0
Kartik

Voici une approche très simple mais peu sûre pour trouver la racine carrée d'un nombre. Dangereux car il ne fonctionne que par des nombres naturels, où vous savez que la base ou l'exposant sont des nombres naturels. J'ai dû l'utiliser pour une tâche où je n'étais pas autorisé à utiliser la # include <cmath> -library, ni à utiliser des pointeurs.

puissance = exposant de base ^ 

// FUNCTION: square-root
int sqrt(int x)
{
    int quotient = 0;
    int i = 0;

    bool resultfound = false;
    while (resultfound == false) {
        if (i*i == x) {
          quotient = i;
          resultfound = true;
        }
        i++;
    }
    return quotient;
}
0
PatrickSteiner