Имеем :

#include <iostream>

void f ( double d1, double d2, char * s1, char * s2 )
{
    if ( d1 == d2 )
        std::cout << s1 <<  "==" << s2 << std::endl;
    else
        std::cout << s1 <<  "!=" << s2 << std::endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
    double _d010000000000000002 = 0.010000000000000002;
    double _d010000000000000001 = 0.010000000000000001;
    double _d010000000000000000 = 0.010000000000000000;
    double _d009999999999999999 = 0.009999999999999999;

    double _d01 = 0.01;

    f ( _d01, _d009999999999999999, "0.01", "0.009999999999999999" );
    f ( _d01, _d010000000000000002, "0.01", "0.010000000000000002" );
    f ( _d01, _d010000000000000001, "0.01", "0.010000000000000001" );
    f ( _d01, _d010000000000000000, "0.01", "0.010000000000000000" );

    double _d06 = 0.06;

    double _d059999999999999998 = 0.059999999999999998;
    double _d060000000000000005 = 0.060000000000000005;

    f ( _d06, _d059999999999999998, "0.06", "0.059999999999999998" );
    f ( _d01, _d059999999999999998, "0.06", "0.059999999999999998" );

    double _d3 = 0.05 + 0.01;
    f ( _d3, _d060000000000000005, "0.05 + 0.01", "0.060000000000000005" );
    f ( _d3, _d059999999999999998, "0.05 + 0.01", "0.059999999999999998");

    double _d4 = 0.6 / 10.;
    
    f ( _d4, _d060000000000000005, "0.6 / 10.  ", "0.060000000000000005" );
    f ( _d4, _d059999999999999998, "0.6 / 10.  ", "0.059999999999999998" );
    
    double _d5 = 0.006 * 10.;
    f ( _d5, _d060000000000000005, "0.006 * 10.", "0.060000000000000005" );
    f ( _d5, _d059999999999999998, "0.006 * 10.", "0.059999999999999998" );

    double _d6 = 0.6 * 0.1;

    f ( _d6, _d060000000000000005, "0.6 * 0.01 ", "0.060000000000000005" );
    f ( _d6, _d059999999999999998, "0.6 * 0.01 ", "0.059999999999999998" );

    double _d7 = 0.006 / 0.1;

    f ( _d7, _d060000000000000005, "0.006 / 0.1", "0.060000000000000005" );
    f ( _d7, _d059999999999999998, "0.006 / 0.1.", "0.059999999999999998" );
    return -1;
}

Понятно что есть "не точность", представления, понятно что есть "не точность вычисления".
Но как быть с ошибкой сложения?

То есть хотелось бы получив некое число (не известно как оно было полученно, например "сложением") как-то его, так "обработать" чтобы получить его равным форме представления.

То есть 0.060000000000000005 -> 0.059999999999999998 при условии что известна точность представления числа. То есть число "десятичных" разрядов после запятой.

То есть значение 0.060000000000000005 это 0.06, а 0.06 это 0.059999999999999998.

Желательно это делать не путем умножения на точность, а путем нормализации до формы представления.

Как?