Unterschiedliche Ergebnisse bei float und long

[Juri (Gast)]

Hallo!

Hab folgende Codezeilen:

  
float one_ticks;
unsigned long clk;
unsigned char divider;
unsigned long ticks;
unsigned long time_us;

....

one_ticks = (float) (((float)divider) / ((float) clk)); //seconds
one_ticks = one_ticks * 1e6; //µs
ticks = (unsigned long)(time_us / one_ticks);

Nicht schön, aber funktioniert.

Nun wollte ich den Code optimieren und vor allem mit integer/long 
rechnen.
Die einzelnen Rechenschritte zusammengefasst sieht dann theoretisch so 
aus:

ticks = (unsigned long) ((time_us * clk) / (divider * 1e6));

Aber funktionieren tut's nicht! - Was mache ich falsch?
Wie optimiere ich richtig?

Danke für eure Hilfe.

Gruß
Juri

[Ingo L. (Gast)]

Und was geht nicht?

[Juri (Gast)]

Es kommt einfach ein anderes Ergbnis raus.
Die float-Funktion liefert z.B 5000 zurück, die long-Version 162.

Das ganze läuft übrigens auf einem MSP430F2418.

[egbert (Gast)]

Du verwendest offensichtlich etwas, was fälschlicherweise als 
Programmiersprache bezeichnet wird, jedoch aufgrund der uneindeutigen 
und meist compilerabhängigen Sprachdefinition bzw. Implementation mehr 
oder weniger zufällige Ergebnisse liefert. Diesen "C"-Quatsch sollte man 
nur verwenden, sofern einem langweilig oder das Ergebnis egal ist. 
Benutze besser eine richtige bzw. professionelle Programmiersprache, 
dann must Du dich nicht mit solchem Kinderkram herumschlagen.

Gruß,
Egbert

[Juri (Gast)]

Was ist denn das für eine Antwort!?!?

[Floh (Gast)]

egbert schrieb:
> Benutze besser eine richtige bzw. professionelle Programmiersprache,
Beispielsweise?

[(prx) A. K. (prx)]

Juri schrieb:

> (divider * 1e6)

Auf diese Art wirst du Fliesskommarechnung aber nicht los.

[Juri (Gast)]

Floh schrieb:
> Beispielsweise?

Das habe ich mich auch gefragt.

A. K. schrieb:
> Auf diese Art wirst du Fliesskommarechnung aber nicht los.

Wegen dem "1e6"!? Soll ich dann lieber 1000000 schreiben?

[(prx) A. K. (prx)]

Korrekt erkannt.

[Peter II (Gast)]

unsigned char divider;
(divider * 1e6));

das pass aber nicht in ein unsigned char

besser sollte es so sein:

(divider * 1e6ul));

[temp (Gast)]

Wenn wir dem egbert alles wegnehmen was in C geschrieben ist, kann er 
wieder mit dem Brummkreisel spielen. Und so einen Mist schreiben kann er 
dann auch nicht mehr.

[(prx) A. K. (prx)]

Juri schrieb:

>> Beispielsweise?
>
> Das habe ich mich auch gefragt.

Er meint T/PL, auch bekannt als Troll Programming Language.

[(prx) A. K. (prx)]

Peter II schrieb:

> (divider * 1e6ul));

War das nicht 1uL6? ;-)

[Juri (Gast)]

Zurück zu meinem Problem:
Dieses befand sich zwischen Tastatur und Stuhllehne.
Wenn time_us = 5.000 und clk = 8.000.000 (Punkt = 1000er Trennzeichen) 
hat man bei der Berechnung von
(time_us * clk) eigentlich das Ergebnis von 40.000.000.000 . Das passt 
aber in einen unsigned long mit 2^32-1=4.294.967.295 nicht rein. 
Überlauf, anderes Ergebnis...

Ein wenig umgestellt, um die Wertebereiche einzuhalten und schon 
funktionierts:

ticks = ((clk/1000000)*time_us)/divider

[Juri (Gast)]

A. K. schrieb:
> Er meint T/PL, auch bekannt als Troll Programming Language.

Wo kann man die lernen? ;)

[Karl H. (kbuchegg)]

Juri schrieb:
> A. K. schrieb:
>> Er meint T/PL, auch bekannt als Troll Programming Language.
>
> Wo kann man die lernen? ;)

Die muss man nicht lernen. Das ist ja das Geniale daran.

[Karl H. (kbuchegg)]

Juri schrieb:

> Ein wenig umgestellt, um die Wertebereiche einzuhalten und schon
> funktionierts:
>

ticks = ((clk/1000000)*time_us)/divider

Das Problem könnte jetzt höchstens noch sein, dass du bei clk/1000000 zu 
viel verlierst. Bei deinen 8Mio geradeaus ist das kein Problem. Bei 
anderen Frequenzen mag das aber zu einem werden. Dann müsste man zb mal 
untersuchen, ob man nicht die Division auf 2 mal aufteilt

Ala

  ticks = ((clk/1000)*time_us/1000)/divider;

Reine Mathematik hat mit den realen Gegebenheiten in einem Computer 
manchmal nur wenig zu tun.

[Willi (Gast)]

Karl Heinz Buchegger schrieb:
>> Wo kann man die lernen? ;)
>
> Die muss man nicht lernen. Das ist ja das Geniale daran.

Köstlich!