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:
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
Alles anzeigen
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.