double a = 1e10;
double epsilon = a;
while((a + epsilon/2) != a) epsilon /= 2;

                double a = 1e10;
                double epsilon = a;
                int i = 0;
                while ((a + epsilon / 2) != a)
                {
                    epsilon /= 2;
                    ++i;
                }
                Console.WriteLine("{0}, {1}, {2}, {3}", a, epsilon, a / Math.Pow(2, 53), i);

Single Precision
The IEEE single precision floating point standard representation requires a 32 bit word, which may be represented as numbered from 0 to 31, left to right. The first bit is the sign bit, S, the next eight bits are the exponent bits, 'E', and the final 23 bits are the fraction 'F':

Double Precision
The IEEE double precision floating point standard representation requires a 64 bit word, which may be represented as numbered from 0 to 63, left to right. The first bit is the sign bit, S, the next eleven bits are the exponent bits, 'E', and the final 52 bits are the fraction 'F':

using System;

namespace Epsilon
{
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            // Неверный способ для float.
            float epsilon = 1.0f;
            float one = 1.0f;
            int i = 0;
            while( one + epsilon/2 != one )
            {
                epsilon /= 2.0f;
                i ++;
            }
            one = one + epsilon;
            one = one - 1.0f;
            Console.WriteLine( "Неверный способ для float" );
            Console.WriteLine( "{0} {1}", one, i );
            Console.WriteLine();
            
            // epsilon для float.
            epsilon = 1.0f;
            one = 1.0f;
            float tmp = one;
            i = 0;
            while( (float)(one + epsilon/2.0f) != (float)one )
            {
                epsilon /= 2.0f;
                i ++;
            }
            Console.WriteLine( "epsilon для float" );
            tmp = tmp + epsilon;
            epsilon = tmp - one;
            Console.WriteLine( "{0} {1}", epsilon, i );
            Console.WriteLine();
            
            // epsilon для double.
            double epsilonD = 1.0;
            double oneD = 1.0;
            double tmpD = oneD;
            i = 0;
            while( oneD + epsilonD/2.0 != oneD )
            {
                epsilonD /= 2.0;
                i ++;
            }
            Console.WriteLine( "epsilon для double" );
            tmpD = tmpD + epsilonD;
            epsilonD = tmpD - oneD;
            Console.WriteLine( "{0} {1}", epsilonD, i );
            Console.WriteLine();
            
            // epsilon для заданного числа a типа float.
            float a = 0.01234567f;
            tmp = a;
            epsilon = a * 1.192093E-07f;
            i = 0;
            while( (float)(a + epsilon/2.0f) != (float)a )
            {
                epsilon /= 2.0f;
                i ++;
            }
            Console.WriteLine( "epsilon для заданного числа " + a.ToString() + " типа float" );
            tmp = tmp + epsilon;
            epsilon = tmp - a;
            Console.WriteLine( "{0} {1}", epsilon, i );
            Console.WriteLine();
            
            // epsilon для заданного числа a типа double.
            double aD = 0.0123456789112345;
            tmpD = aD;
            epsilonD = aD * 2.22044604925031E-16;
            i = 0;
            while( aD + epsilonD/2.0 != aD )
            {
                epsilonD /= 2.0;
                i ++;
            }
            Console.WriteLine( "epsilon для заданного числа " + aD.ToString() + " типа double" );
            tmpD = tmpD + epsilonD;
            epsilonD = tmpD - aD;
            Console.WriteLine( "{0} {1}", epsilonD, i );
            Console.WriteLine();

            // epsilon для числа 1 типа float.
            a = 1.0f;
            tmp = a;
            epsilon = a * 1.192093E-07f;
            i = 0;
            while( (float)(a + epsilon/2.0f) != (float)a )
            {
                epsilon /= 2.0f;
                i ++;
            }
            Console.WriteLine( "epsilon для числа 1 типа float" );
            tmp = tmp + epsilon;
            epsilon = tmp - a;
            Console.WriteLine( "{0} {1}", epsilon, i );
            Console.WriteLine();
            
            // epsilon для заданного числа 1 типа double.
            aD = 1.0;
            tmpD = aD;
            epsilonD = aD * 2.22044604925031E-16;
            i = 0;
            while( aD + epsilonD/2.0 != aD )
            {
                epsilonD /= 2.0;
                i ++;
            }
            Console.WriteLine( "epsilon для числа 1 типа double" );
            tmpD = tmpD + epsilonD;
            epsilonD = tmpD - aD;
            Console.WriteLine( "{0} {1}", epsilonD, i );
            
            Console.ReadLine();
        }
    }
}

Неверный способ для float
0 52

epsilon для float
1,192093E-07 23

epsilon для double
2,22044604925031E-16 52

epsilon для заданного числа 0,01234567 типа float
9,313226E-10 1

epsilon для заданного числа 0,0123456789112345 типа double
1,73472347597681E-18 1

epsilon для числа 1 типа float
1,192093E-07 1

epsilon для числа 1 типа double
2,22044604925031E-16 0

ШЕ> Только не врубился к какому мнению (коду) господа пришли ?

if(fabs(a-b) <= DBL_EPSILON * max(fabs(a), fabs(b)))
{
   ...equal
}

MS>double a = 1e10;
MS>double epsilon = a;
MS>while((a + epsilon/2) != a) epsilon /= 2;
MS>

std::numeric_limits<double>::epsilon()

MS>if(fabs(a-b) <= DBL_EPSILON * max(fabs(a), fabs(b)))
MS>{
MS>   ...equal
MS>}
MS>

Double Precision
The IEEE double precision floating point standard representation requires a 64 bit word, which may be represented as numbered from 0 to 63, left to right. The first bit is the sign bit, S, the next eleven bits are the exponent bits, 'E', and the final 52 bits are the fraction 'F':

S EEEEEEEEEEE FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
0 1 11 12 63

The value V represented by the word may be determined as follows:

If E=2047 and F is nonzero, then V=NaN ("Not a number")
If E=2047 and F is zero and S is 1, then V=-Infinity
If E=2047 and F is zero and S is 0, then V=Infinity
If 0<E<2047 then V=(-1)**S * 2 ** (E-1023) * (1.F) where "1.F" is intended to represent the binary number created by prefixing F with an implicit leading 1 and a binary point.
If E=0 and F is nonzero, then V=(-1)**S * 2 ** (-1022) * (0.F) These are "unnormalized" values.
If E=0 and F is zero and S is 1, then V=-0
If E=0 and F is zero and S is 0, then V=0

typedef unsigned __int64 uint;
void f(double v)
{
    v=v;
    uint* uv=(uint*)&v;

    double g=v;
    uint* ug=(uint*)&g;
    ++*ug;
    ug=ug;
}

int main(int argc, char** argv)
{
    f(1.0);
    f(std::numeric_limits<double>::epsilon());
    f(16.0);
    f(-16.0);
    f(-std::numeric_limits<double>::infinity());
}

    v    1.0000000000000000    double
    *uv    0x3ff0000000000000    unsigned __int64
    g    1.0000000000000002    double
    *ug    0x3ff0000000000001    unsigned __int64

    v    2.2204460492503131e-016    double
    *uv    0x3cb0000000000000    unsigned __int64
    g    2.2204460492503136e-016    double
    *ug    0x3cb0000000000001    unsigned __int64

    v    16.000000000000000    double
    *uv    0x4030000000000000    unsigned __int64
    g    16.000000000000004    double
    *ug    0x4030000000000001    unsigned __int64

    v    -16.000000000000000    double
    *uv    0xc030000000000000    unsigned __int64
    g    -16.000000000000004    double
    *ug    0xc030000000000001    unsigned __int64

typedef unsigned __int64 uint;
bool fast_is_same(double a,double b)
{
    switch(*reinterpret_cast<uint*>(&a)-*reinterpret_cast<uint*>(&b))
    {
    case 1:
    case (uint)-1:
        return true;
    }
    return false;
}