Kiedy używać std :: hypot `(x, y)` `nad std :: sqrt (x * x + y * y)`

Question

documentation of std::hypot mówi, że:

Oblicza pierwiastek kwadratowy z suma kwadratów xiy, bez zbędnego przepełnienia lub niedomiaru na pośrednich etapach obliczeń.

walczę wyobrazić przypadek testowy gdzie std::hypot powinny być wykorzystywane w trywialny sqrt(x*x + y*y).

Poniższy test pokazuje, że std::hypot jest mniej więcej 20 razy wolniejszy od obliczeń naiwnych.

#include <iostream> 
#include <chrono> 
#include <random> 
#include <algorithm> 

int main(int, char**) { 
    std::mt19937_64 mt; 
    const auto samples = 10000000; 
    std::vector<double> values(2 * samples); 
    std::uniform_real_distribution<double> urd(-100.0, 100.0); 
    std::generate_n(values.begin(), 2 * samples, [&]() {return urd(mt); }); 
    std::cout.precision(15); 

    { 
     double sum = 0; 
     auto s = std::chrono::steady_clock::now(); 
     for (auto i = 0; i < 2 * samples; i += 2) { 
      sum += std::hypot(values[i], values[i + 1]); 
     } 
     auto e = std::chrono::steady_clock::now(); 
     std::cout << std::fixed <<std::chrono::duration_cast<std::chrono::microseconds>(e - s).count() << "us --- s:" << sum << std::endl; 
    } 
    { 
     double sum = 0; 
     auto s = std::chrono::steady_clock::now(); 
     for (auto i = 0; i < 2 * samples; i += 2) { 
      sum += std::sqrt(values[i]* values[i] + values[i + 1]* values[i + 1]); 
     } 
     auto e = std::chrono::steady_clock::now(); 
     std::cout << std::fixed << std::chrono::duration_cast<std::chrono::microseconds>(e - s).count() << "us --- s:" << sum << std::endl; 
    } 
} 

Więc pytam dla orientacji, gdy muszę używać std::hypot(x,y) celu uzyskania poprawnych wyników nad znacznie szybciej std::sqrt(x*x + y*y).

Wyjaśnienie: szukam odpowiedzi, które obowiązują podczas x i y są liczb zmiennoprzecinkowych. To znaczy. porównaj:

double h = std::hypot(static_cast<double>(x),static_cast<double>(y)); 

do:

double xx = static_cast<double>(x); 
double yy = static_cast<double>(y); 
double h = std::sqrt(xx*xx + yy*yy); 

Answer 1

Odpowiedź jest w dokumentacji, którą cytowany

Oblicza pierwiastek kwadratowy z sumy kwadratów xiy, bez zbędnej przepełnienie lub niedomiar na pośrednich etapach obliczeń.

If x*x + y*y przepełnienia, a następnie, jeśli przeprowadzają obliczenia ręcznie, dostaniesz złą odpowiedź. Jeśli jednak używasz std::hypot, gwarantuje to, że obliczenia pośrednie nie będą przepełnione.

Możesz zobaczyć przykład tej rozbieżności here.

Jeśli pracujesz z liczbami, o których wiesz, że nie przepełnią one odpowiedniej reprezentacji twojej platformy, możesz z powodzeniem użyć naiwnej wersji.