Как обнаружить потерю точности при умножении двух double

#include <iostream>
 
int main()
{
    float f = 5.23;
   if (f == 5.23)
     std::cout << "foobar";
}

#include <iostream>
 
int main()
{
  float f = static_cast<float>(5.2300000000000004);
  if(static_cast<double>(f) == 5.2300000000000004) {
    std::operator<<(std::cout, "foobar");
  } 
  
  return 0;
}

#include <iostream>
#include <limits>
 
double multiply(double a, double b){
   double res = a * b;
   if (res == std::numeric_limits<double>::infinity() || res == -std::numeric_limits<double>::infinity()) 
      throw "overflow";
   if (a && b && (res / a != b || res / b != a)) 
      throw "accloss";
   return res ? res : 0.0;
}
 
int main(){
   double a = 1.124;
   double b = 5.0005; 
 
   if (multiply(a,b) != 5.620562 )
      std::cout << "Ooops!" << std::endl;
}

if (value < epsilon) ...
...
if (!(value < MAX_VAL)) ...

double x = 1.1;
double y = x * x;
std::cout << std::setprecision(20) << y << "\n"; // выводит: 1.2100000000000001865

#include <iostream>
#include <cmath>
#include <iomanip>
 
bool hasPrecisionLoss(double a, double b, double product) {
    if (a == 0 || b == 0) return false; // особый случай
 
    // Вычисляем "идеальный" результат с помощью long double (если поддерживается)
    long double precise = static_cast<long double>(a) * static_cast<long double>(b);
    double precise_double = static_cast<double>(precise);
 
    // Если преобразование long double → double не изменило значение,
    // значит, double мог точно представить результат → потерь нет.
    // Но если есть расхождение — значит, double не смог сохранить всю точность.
 
    if (precise_double == product) {
        // Результат в double совпал с более точным вычислением → возможно, потерь нет
        // Но это ещё не гарантирует — см. ниже!
        return false;
    }
 
    // Теперь сравним с абсолютной погрешностью
    double abs_error = std::abs(product - precise_double);
    double rel_error = abs_error / std::abs(precise_double);
 
    // Порог: считаем, что потеря точности есть, если относительная ошибка > 1 ULP
    // ULP для double ≈ 2^(-52) ≈ 2.22e-16
    const double eps = std::numeric_limits<double>::epsilon(); // ~2.22e-16
    const double threshold = 10 * eps; // допустим 10 ULP — очень консервативно
 
    return rel_error > threshold;
}
 
int main() {
    double a = 1.23456789012345;
    double b = 9.87654321098765;
    double c = a * b;
 
    if (hasPrecisionLoss(a, b, c)) {
        std::cout << "Обнаружена потеря точности!\n";
    } else {
        std::cout << "Точность сохранена.\n";
    }
 
    std::cout << "a = " << std::setprecision(17) << a << "\n";
    std::cout << "b = " << std::setprecision(17) << b << "\n";
    std::cout << "a*b (double) = " << c << "\n";
 
    long double precise = static_cast<long double>(a) * static_cast<long double>(b);
    std::cout << "a*b (long double) = " << std::setprecision(20) << precise << "\n";
 
    return 0;
}

#include <boost/multiprecision/cpp_dec_float.hpp>
using namespace boost::multiprecision;
 
int main() {
    cpp_dec_float_50 a("1.23456789012345");
    cpp_dec_float_50 b("9.87654321098765");
    auto precise = a * b;
 
    double da = static_cast<double>(a);
    double db = static_cast<double>(b);
    double dc = da * db;
 
    cpp_dec_float_50 dc_precise(dc); // преобразуем обратно
    auto error = std::abs(precise - dc_precise);
 
    if (error > 1e-15) {
        std::cout << "Потеря точности: " << error << "\n";
    }
}

#include <cmath>
#include <cfloat>
 
bool likelyPrecisionLoss(double a, double b) {
    if (a == 0 || b == 0) return false;
 
    // Подсчёт значащих цифр в десятичном представлении
    int digits_a = static_cast<int>(std::floor(std::log10(std::abs(a)))) + 1;
    int digits_b = static_cast<int>(std::floor(std::log10(std::abs(b)))) + 1;
 
    // Если сумма значащих цифр > 16, то потеря точности почти гарантирована
    // (так как double хранит ~15-17 десятичных цифр)
    return digits_a + digits_b > 16;
}

#include <iostream>
#include <limits>
 
int main()
{
    std::cout<< std::numeric_limits<double>::is_iec559 << std::endl;
    std::cout<< std::numeric_limits<float>::is_iec559;
}