long long und double größe

pyhax

Hi,

kann mir jemand sagen ob double und long long immer die gleiche größe haben ?

SG1

Nein, das ist nicht garantiert.

pyhax

// Initial AlmostEqualULPs version - fast and simple, but

// some limitations.

bool AlmostEqualUlps(float A, float B, int maxUlps)

{

    assert(sizeof(float) == sizeof(int));

    if (A == B)

        return true;

    int intDiff = abs(*(int*)&A - *(int*)&B);

    if (intDiff <= maxUlps)

        return true;

    return false;

}

von http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm

Also kann es sein, dass dieser Code (für double müsste ich dann ja long long nehmen, oder?), nicht auf allen Systemen funktioniert? Gibt es da irgendeine Möglichkeit das zu umgehen? Und kennt jemand ein System bei dem sizeof(double)!=sizeof(long long)? (Nicht Embedded)

volkard

pyhax schrieb:

Also kann es sein, dass dieser Code (für double müsste ich dann ja long long nehmen, oder?), nicht auf allen Systemen funktioniert? Gibt es da irgendeine Möglichkeit das zu umgehen?

Ja. Geh mit Template-Metaprogrammierung durch eine Typenliste und nimm den ersten, der groß genug ist.
Aber dann haste immernoch das Problem, daß die iunterne Darstellung von ints und von Fließkommazahlen nicht garantiert ist. Also nix gewonnen.

Ethon

Du könntest mit Boost.Integer den passenden Integer-Typ zur Laufzeit rauskramen. Also:

template<typename Float>
bool AlmostEqualUlps(Float a, Float b, int maxUlps)
{
    static_assert(std::is_float<Float>::value, "Float expected");
    typedef boost::int_t<sizeof(Float) * CHAR_BITS>::least integer;
    static_assert(sizeof(integer) == sizeof(Float), "Size mismatch");

    if(a == b)
        return true;

    int intDiff = std::abs(*(integer*)&a - *(integer*)&b);
    if (intDiff <= maxUlps)
        return true;

    return false;
}

pyhax

Ethon schrieb:

Du könntest mit Boost.Integer den passenden Integer-Typ zur Laufzeit rauskramen. Also:

template<typename Float>
bool AlmostEqualUlps(Float a, Float b, int maxUlps)
{
    static_assert(std::is_float<Float>::value, "Float expected");
    typedef boost::int_t<sizeof(Float) * CHAR_BITS>::least integer;
    static_assert(sizeof(integer) == sizeof(Float), "Size mismatch");

    if(a == b)
        return true;

    int intDiff = std::abs(*(integer*)&a - *(integer*)&b);
    if (intDiff <= maxUlps)
        return true;

    return false;
}

Wieso zur Laufzeit? Ich sehe da nur typedef's und static_assert's

Ethon

Ehm, zur Compile-Zeit. *Dong...*

pyhax

OK dann ist das genau das was ich suche.

EDIT: Mir ist gerade nochwas aufgefallen (sinnlos, aber was soll's :D)

volatile register const unsigned long long int myConst = 0;

Woah