Plus / Plus = Minus?

[Seren200018]

Irgendwie spinnt diese Funktion hier bei mir

Delphi-Quellcode:

Baseexp,startbaseexp,seconds : integer
Baseperhour                  : real

Baseperhour := ((exp.Baseexp-exp.startbaseexp)*60*60/Seconds);

Die Werte die heraus kommen sind:

seconds = 1781
Baseexp = 2.539.006
startbaseexp = 1.935.338
Baseperhour = -1.191.332,1145

Ich bin darum etwas verwundert.

Ps: Die Funktion ABS kann ich hier nicht benutzen.

[Wolfgang Mix]

Zitat:

Baseperhour := ((exp.Baseexp-exp.startbaseexp)*60*60/Seconds);

Versuche 'mal
Baseperhour := (exp(Baseexp)-exp(startbaseexp))*60*60/Seconds); Gruß

Wolfgang

[Seren200018]

das exp. ist ein record das ist etwas umfangreicher darum habe ich nur die Typen der endzweige die man hier sieht
angegeben.
Es ist nicht die EXP funktion aber ich werde es in meinem Programm noch mal wechseln damit es verständlicher ist.

[Hawkeye219]

Hallo,

der Zähler in deinem Bruch erzeugt einen Integer-Overflow, der zum Vorzeichenwechsel führt. Du kannst so vorgehen:

Baseperhour := ((exp.Baseexp - exp.startbaseexp) * 60.0 * 60 / Seconds); // beachte die "60.0" Auf diese Weise wird der Zähler als Real-Wert berechnet.

Gruß Hawkeye

[Seren200018]

ahhh vielen dank =)

[himitsu]

Delphi-Quellcode:

Baseperhour := (2.539.006 - 1.935.338) * 60 * 60 / 1781;
Baseperhour := 2.173.204.800 {$81887940} / 1781;

da es bis zum / alles Integer sind, wird da nur mit Integern
gerechnet und da liegt das Zwischenergebnis außerhalb des Wertebereichs.

PS: mit aktiver Überlaufprüfung wäre dieses aufgefallen!

Delphi-Quellcode:

// wurde schon genannt
Baseperhour := (exp.Baseexp - exp.startbaseexp) * 60.0 * 60 / Seconds;

// das wäre auch gegangen
Baseperhour := Real(exp.Baseexp - exp.startbaseexp) * 60 * 60 / Seconds;

und diese beiden (gibt noch mehr) Möglichkeiten verschieben die Berechnung (für diese Werte) rechtzeitig in von Integer- in die Fließkommaberechnung.

und falls sogar die Negation schon den Integerbereich sprengen könnte, dann so

Delphi-Quellcode:

// das wäre auch gegangen
Baseperhour := (Real(exp.Baseexp) - exp.startbaseexp) * 60 * 60 / Seconds;

[Medium]

Eine weitere Variante wäre es die Zwischenergebnisse erst garnicht so groß werden zu lassen. Das ist in diesem Fall sogar sehr einfach:

(exp.Baseexp-exp.startbaseexp)/(Seconds/3600);

Da Seconds vermutlich in der Regel ebenfalls irgendwo in oder über den Tausendern liegt, handelt man sich damit auch nur verschwindend geringe Ungenauigkeiten ein. Normalerweise sollte man das Dividieren von Teiltermen durch größere Werte* vermeiden, da sonst extrem kleine Zwischenergebnisse entstehen können, die merkliche Fehler einbringen können. In diesem Fall sind wir aber denke ich locker um einen mindestens 6-stelligen Faktor davon entfernt überhaupt was davon zu merken

*) Heisst: Quotient zigtausendfach größer als Dividend.

[alzaimar]

Ich mache mir zur Regel, in so einer Formel den erstbesten inneren Integer-Wert mit 1.0 zu multiplizieren. Das veranlasst den Compiler, ALLES gleich als floating Point umzuformen.

Zitat von Seren200018:

Baseperhour := ((1.0*exp.Baseexp-exp.startbaseexp)*60*60/Seconds);