64 Bit Rechenoperationen

RHBaum

also folgendes problem ...

ich muss 64 bit zeitstempel korrelieren ... also angleichen sozusagen.

zwei externe zeitquellen liefern die signale, und haben eine gewisse drift. nun muss ich das eine signal zum anderen aufkorrelieren ...

irgendwann lauf ich dann mal auf ne rechenoperation raus, wo ich multiplizieren bzw. dividieren muss, das mit 64 bit integer ...

also ne formel ala tx = ax * (t2 - t1) / (a2-a1)

einer ne ahnnung wie man das mit 64 bit moeglichst genau rechnen kann, die implizite konvertierung nach double bringt natuerlich ungenauigkeiten jenseits von gut und boese .....

Ciao ...

Talla

Hast du in der Sprache mit der du programmierst keine 64Bit Datentypen? Und sind das Fließkommazahlen oder Ganzzahlen?

Bashar

RHBaum schrieb:

irgendwann lauf ich dann mal auf ne rechenoperation raus, wo ich multiplizieren bzw. dividieren muss, das mit 64 bit integer ...

Multiplikation geht vielleich so:

X = (A * 2^32) + B
Y = (C * 2^32) + D

=> X*Y = ((A * 2^32) + * (C * 2^32) + D)
= A*C*2^64 + (A*D + B*C)*2^32 + B*D

Divison ... (???)

RHBaum

klar hab ich 64 bit datentypen

es sind GanzZahltypen .... genauer gesagt unsigned __int64;
wobei es ein zeitstempel in nanosekunden ist.

__int64

nur bekomme ich dementsprechend ueberlaufe ....

__int64 * __int64 gibt ganz schnell ueberlauf = ergebniss fuer die tonne ...

__int64 * double = double ... double -> __int64 -> sehr ungenau

Ciao ...

camper

ich schätze mal, (t2-t1)/(a2-a1) ist konstant, dann sollte man es evtl. vorausberechnen:

typedef __int64 i64;
typedef unsigned __int64 u64;
typedef std::pair<i64,u64> dt;

dt computeDt(i64 deltaT, i64 deltaA)
{
    i64 quotient = deltaT / deltaA;
    if( deltaT < 0 ) deltaT = -deltaT;
    if( deltaA < 0 ) deltaA = -deltaA;
    u64 temp = deltaT % deltaA;
    u64 quotientFrac = 0;
    for( i = 0; i <= 64; ++i )
    {
        temp <<= 1;
        quotientFrac <<= 1;
        qoutientFrac += temp / deltaA;
        temp %= deltaA;
    }
    return std::make_pair( quotient, quotientFrac );
}

i64 operator*(i64 lhs, const dt& rhs)
{
    u64 temp = rhs.second;
    i64 result = 0;
    for( i = 0; i < 64; ++i )
    {
        if( temp & 1 ) result += lhs;
        result >>= 1;
    }
    result += rhs.first * lhs;
    return result;
}

ungetestet und ineffizient, hab es mir grad aus den fingern gesogen.

Bashar schrieb:

Divison ... (???)

Primfaktorzerlegung und wenn's ne Primzahl ist, Pech gehabt. Ah ne, dafür braucht man ja den ggT.
Naja die meisten compiler ham doch Unterstützung für 64 Bit-Typen, da würd ich einfach mal den Assembler-Code ansehen. Oder auch nicht und einfach verwenden. :p

Power Off

RHBaum schrieb:

__int64 * __int64 gibt ganz schnell ueberlauf = ergebniss fuer die tonne ...

Dann bringen Dir auch 64 Bit Integer nix.

Such mal im Web nach einer Library fuer beliebig genaue Ganz- oder Fliesskommazahlen (oft BigInt oder BigFloat genannt).

fit

zur not mit libs für grosse zahlen, wie gmp arbeiten (nur wenns nicht anders geht, da ops rel. langsam)