Чтобы найти квадратный корень с точностью

Question

Я просто изучал вопросы, которые разные компании задают в интервью.Я нашел одно: «Найти квадратный корень числа с точностью. Определение функции должно быть примерно таким: double getSquareRoot(int num, int precision)».

Я написал одну маленькую функцию, которая дает квадратный корень, но это не волнуето точности:

double getSquareRoot(int num){
 int num1=0, num2=0;
 for(int i=1 ;; i++){
   if(i*i == num){
    std::cout<<i <<" is the sq root"<<std::endl;
    break;
   }
  else if(i*i > num){
   num2 = i;
   num1 = --i;
   break;
  }
} 
 // in the above for loop, i get the num1 and num2 where my input should lie 
 // between them
 // in the 2nd loop below.. now i will do the same process but incrementing 
 // by 0.005 each time
for(double i =num1;i<(double)num2;i+=0.005)
  {
   if(i*i>= num){
     std::cout<<(double)i <<" is the sq root"<<std::endl;
     break;
   }
 }
}

Теперь, чтобы достичь точности, мне нужно будет сделать несколько настроек, таких как добавление циклов if и все.Мне это не нравитсяНе могли бы вы, ребята, помочь мне здесь?Если вы пишете код, пожалуйста, объясните.Я был бы признателен.

Спасибо.

Этот код очень недостаточен, и он не заботится о "до этой точности" части проблемы.Я написал это только для того, чтобы вы, парни, не думали, что я попробовал немного.Это

Answer 1

От макушки головы есть два подхода:

• Использовать интервал деления пополам ; Вы знаете, что ошибка не превышает ширину текущего интервала, поэтому прекратите итерацию, если интервал меньше требуемой точности. Это очень просто, но не сходится так быстро, как другие методы.
• Используйте итерационный метод, такой как метод Ньютона (также известный как вавилонский метод при использовании для вычисления квадратного корня), и оцените ошибку после каждой итерации.

Чтобы оценить ошибку, предположим, что мы пытаемся найти x0 = sqrt(y), так что x0*x0 = y. После каждой итерации у нас появляется кандидат x = x0 + d, и мы хотим оценить ошибку d. Если мы возведем в квадрат x, то получим

x*x = x0*x0 + 2*x0*d + d*d
    = y + 2*(x-d)*d + d*d
   ~= y + 2*x*d

отбрасывает d*d условия, которые становятся очень маленькими, когда d становится маленькими Таким образом, мы можем оценить ошибку как

d ~= (x*x - y) / (2*x)
   = (x - y/x) / 2

и прекратите итерацию, если она меньше требуемой точности.

Если вы используете вавилонский метод, то это добавляет очень мало работы к итеративному вычислению, x = (x + y/x) / 2, поэтому в результате получается что-то вроде

double sqrt(double y, double precision)
{
    double x = y;  // or find a better initial estimate
    for (;;) {
        double z = y/x;
        if (std::abs(x-z) < 2*precision)
            return x;
        x = (x+z)/2;
    }
}

Answer 2

Ищите здесь несколько алгоритмов: Методы вычисления квадратных корней

Answer 3

Возможно, лучший ответ в этом случае: использовать библиотеку больших чисел, такую ​​как GNU MP Bignum . Он обеспечивает mpf_sqrt и аналогичные функции. Точность по умолчанию для чисел с плавающей запятой может быть установлена ​​с помощью mpf_set_default_prec .

Лучшее, - Кристоф

Answer 4

Вот мое решение ::

double root(int num)
{
  double l=0,m=num,h=num,om=0;

       while(m-om)
       {
            om=m;
            m=(l+h)/2.0;
            if(m*m < num)
            {
                l = m;             
            }
            else if(m*m > num)
            {
                h=m;
            }
       }
       return m;
 }