Autoit - Gleitkommazahlen abrunden

Gruß zur Stunde werte AutoIt Gemeinde,
als ich mich mal mit der allgemeinen Typkonvertierung beschäftigte kam mir die Idee mal zu untersuchen welche Operationen in AutoIt schneller sind.
Dafür verwendete ich folgendes, weitestgehend selbst erklärendes Script:

#include <Array.au3>


;------- PARAMETER
Global $iNumbers = 10000
Global $iDurchlaufe = 100
;-------


Global $LeerVar = 0
Dim $Numbers[$iNumbers]
Dim $Ergebnisse[$iDurchlaufe][4]
$TimerInt = TimerInit()




For $rounds = 0 To UBound($Ergebnisse) - 1 Step 1
	_GenerateNewNumbers($Numbers)
	$TimerFloor = TimerInit()
	For $i = 0 To UBound($Numbers) - 1 Step 1
		$LeerVar = Floor($Numbers[$i])
	Next
	$Ergebnisse[$rounds][0] = TimerDiff($TimerFloor)


	$TimerIntFloor = TimerInit()
	For $i = 0 To UBound($Numbers) - 1 Step 1
		$LeerVar = Int($Numbers[$i])
	Next
	$Ergebnisse[$rounds][1] = TimerDiff($TimerIntFloor)


	$TimerCeiling = TimerInit()
	For $i = 0 To UBound($Numbers) - 1 Step 1
		$LeerVar = Ceiling($Numbers[$i])
	Next
	$Ergebnisse[$rounds][2] = TimerDiff($TimerCeiling)


	$TimerIntCeiling = TimerInit()
	For $i = 0 To UBound($Numbers) - 1 Step 1
		$LeerVar = Int($Numbers[$i] + 1)
	Next
	$Ergebnisse[$rounds][3] = TimerDiff($TimerIntCeiling)


	ConsoleWrite("Round: " & ($rounds + 1) & "/" & UBound($Ergebnisse) & @CRLF)
Next
Dim $Durchschnitt[6]
For $i = 0 To UBound($Ergebnisse, 2) - 1 Step 1
	For $i2 = 0 To UBound($Ergebnisse) - 1 Step 1
		$Durchschnitt[$i] += $Ergebnisse[$i2][$i]
	Next
	$Durchschnitt[$i] /= UBound($Ergebnisse)
Next
$Durchschnitt[4] = "Nummern: " & $iNumbers
$Durchschnitt[5] = "Durchläufe: " & $iDurchlaufe
;_ArrayDisplay($Ergebnisse)
_ArrayDisplay($Durchschnitt)




Func _GenerateNewNumbers(ByRef $input)
	For $i = 0 To UBound($input) - 1 Step 1
		$input[$i] = Random(0, 1000000000000)
	Next
EndFunc   ;==>_GenerateNewNumbers

Da ich in diesem Script auch "Ceiling" untersuchte ist zu sagen, dass diese Variante nur für alle Zahlen außer ganze Zahlen gilt (ist ja logisch, sonst würde die +1 Methode nicht funktionieren). Also nehme ich an, dass keine Ganzzahl vor kommt bzw. wenn eine kommt das nicht behindern soll, da die Rundungsoperationen untersucht werden.
Bei meinen Tests auf meinem i5-2500k unter Windows 8.1 64 Bit kam folgendes bei raus:
Dabei wird das Ergebnis wie folgt beschrieben:
[Blockierte Grafik: http://i.epvpimg.com/OXdRg.png]
[0] = Floor
[1] = Int
[2] = Ceiling
[3] = Int + 1

Das Ergebnis bei Ceiling und Int + 1 erwartete ich eigentlich schon, da wir hier 2 Rechenoperationen ausführen und mich das nicht überraschend traf.
Die Differenz von Floor zu Int hat mich dann allerdings doch überrascht. Wurde dieser Versuch mit 500.000 Zahlen geführt, so beträgt die Abweichung schon 10ms. Bei 50.000 führte ich sie ebenfalls durch, dabei betrug die Differenz 1ms.
Um ein vernünftiges Ergebnis zu haben würde ich darum bitten dass hier mal ein paar Daten zusammen getragen werden und diese Abweichung nicht nur an meinem System liegt.

Warum das Ganze?
Nun - Man wird im Programmieralltag womöglich nie mit so einer Menge an zufälligen Zahlen, die dann auch noch abgerundet werden sollen, zu tun zu haben (zumindest nicht unter AutoIt). Dennoch interessierte mich diese Untersuchung, und als erstes Fazit nach mehreren Messungen kann ich sagen:

Im Durchschnitt ist die Int Funktion der Floor Funktion zum abrunden vorzuziehen.

Zitat von AspirinJunkie

Vorsicht - gilt nur für positive Zahlen.Bei negativen Zahlen unterscheidet sich das Verhalten!

Hallo AspirinJunkie - Selbstverständlich hast du Recht, was das Verhalten von Floor & Int angeht. In dem Falle müsste man ein "Ceiling" wählen.
Dennoch bleibt der Effekt der gleiche: Das Int ist wieder schneller als die Rundungsoperatin selber.

Demnach kann man nach wie vor festhalten, dass bei bekanntem Signum und gewolltem Floor / Ceiling die Geschwindigkeit des Int() schneller ist als die Geschwindigkeit von Floor() oder Ceiling().

@Alina es geht hier nicht darum ob der Rechner schnell oder langsam ist. Ein gutes Ergebnis wäre in dem Fall die Tatsache dass es mit den nativen Floor & Ceiling Operationen schneller als Int ist sind.