1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. Mars

Beiträge von Mars

  • AutoIt3 Compiler/Parser

    • Mars
    • 1. September 2011 um 19:37

    Der Vorteil ist, dass der C#, C, C++ Code mit immer neuen Compilern immer flotter wird.
    Der AutoIt interpreter optimiert, wenn überhaupt, nicht wirklich viel, was bei Compilern schon eine andere Sache ist.

    Weiterer Vorteil ist die weitaus geringere Dateigröße.
    Bei AutoIt wird immer der ganze Interpreter mitgeschleppt, selbst wenn davon nur 1% benötigt wird.

    Selbst wenn man exakt das, was der Interpreter interpretieren würde als C++ Code speichert wäre die Ausführung nach dem Kompillieren wesentlich schneller.

    Wie schon gesagt wurde bauen die meisten UDF´s auf DllCalls auf. Zur Not muss man eben die UDF´s portieren.

    die Idee ansich hatte ich auch schon und ich finde es gut, dass das auch von anderer Seite aufgegriffen wird.

    Man kann den Übersetzer ja in AutoIt schreiben. Und AutoIt ist einfach.
    Ich sage nicht, dass das ein Zuckerschlecken wird, aber es ist auch nicht so unmöglich, wie es immer dargestellt wird. Dazu haben wir hoer ausreichend Leute die das theoretisch mit etwas Einarbeitung könnten.

    Angefangen wird natürlich erstmal mit kleinen Scripten die man übersetzen lässt. Und anschließend kann man sich an die UDF´s wagen.

    lg
    Mars(i)

  • Suche (schnelle) Funktion zum Umrechnen ins Dual- oder Hexadezimalsystem

    • Mars
    • 31. August 2011 um 14:25

    Habs jetzt mal mit einer hohen Anzahl Durchläufe (5000) und einer engen Abfrage (1.1 Als Multiplikator) alles aufgezeichnet.

    Ich bedanke mich für die Vielen Funktionen die hier gezeigt wurden.
    Daran erkennt man doch auf wie vielen Wegen doch das gleiche (einfache) Ziel erreicht werden kann !

    Wie es zu erwarten war ist die Optimierte Kombinationsmethode (Bei kleinen Zahlen Division und bei Großen die Ausgedachte Methode) am Flottesten, wenn man auf DllCalls verzichtet.
    Der DllCall lässt aber alles alt aussehen. Ab einer Dezimalzahl > 16 liegt der Call mit der Nase vorne.

    Spoiler anzeigen
    [autoit]


    Global $MSVCRT_Dll = DllOpen('msvcrt.dll')

    [/autoit] [autoit][/autoit] [autoit]

    _Main()

    [/autoit] [autoit][/autoit] [autoit]

    DllClose($MSVCRT_Dll)

    [/autoit] [autoit][/autoit] [autoit]

    Func _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Local $Anz_Funktionen = 6
    Local $a[$Anz_Funktionen], $t, $r, $Zeitbedarf[$Anz_Funktionen], $Schritte = 0, $Letzte_Runde = False, $Werte = 0

    [/autoit] [autoit][/autoit] [autoit]

    Local $Versuche = 500, $Excel = False, $Multiplikator = 1.1

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then Sleep(3000)

    [/autoit] [autoit][/autoit] [autoit]

    While $Schritte <= 2 ^ 31 - 1
    ConsoleWrite('Zahl: ' & $Schritte & @CRLF)
    If $Excel Then
    Send($Schritte, 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    EndIf
    For $i = 0 To $Versuche Step 1
    $r = $Schritte
    $t = TimerInit()
    $a[0] = _DecToBin_1($r) ; Divisionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[0] += $t
    $t = TimerInit()
    $a[1] = _DecToBin_2($r) ; Subtraktionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[1] += $t
    $t = TimerInit()
    $a[2] = _DecToBin_3($r) ; Ausgedacht 1
    $t = TimerDiff($t)
    $Zeitbedarf[2] += $t
    $t = TimerInit()
    $a[3] = _IntToBin($r) ; Von Bugfix
    $t = TimerDiff($t)
    $Zeitbedarf[3] += $t
    $t = TimerInit()
    $a[4] = _DecToBin_4($r) ; Kombination der Divisionsmethode und der Ausgedachten.
    $t = TimerDiff($t)
    $Zeitbedarf[4] += $t
    $t = TimerInit()
    $a[5] = _IntToBin_2($r) ; Funktion mit DllCall
    $t = TimerDiff($t)
    $Zeitbedarf[5] += $t
    If ($a[0] <> $a[1]) Or ($a[0] <> $a[2]) Or ($a[0] <> $a[3]) Or ($a[0] <> $a[4]) Or ($a[0] <> $a[5]) Then ; Falls Abweichende Ergebnisse vorkommen ist eine Funktion falsch !
    ConsoleWrite('Error: ' & @CRLF & 'Int: ' & $r & @CRLF & ' 1.Bin: ' & $a[0] & _
    @CRLF & ' 2.Bin: ' & $a[1] & _
    @CRLF & ' 3.Bin: ' & $a[2] & _
    @CRLF & ' 4.Bin: ' & $a[3] & _
    @CRLF & ' 5.Bin: ' & $a[4] & _
    @CRLF & ' 6.Bin: ' & $a[5] & _
    @CRLF)
    EndIf
    Next

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then
    For $_i = 0 To $Anz_Funktionen - 1 Step 1
    Send(Round(($Zeitbedarf[$_i] / $Versuche) * 10000, 0), 1)
    Sleep(70)
    Send('{RIGHT}')
    Sleep(70)
    Next
    Send('{ENTER}')
    For $_i = 0 To $Anz_Funktionen Step 1
    Sleep(70)
    Send('{LEFT}')
    Next
    Else
    ConsoleWrite('Func 1: ' & Round($Zeitbedarf[0] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 2: ' & Round($Zeitbedarf[1] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 3: ' & Round($Zeitbedarf[2] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 4: ' & Round($Zeitbedarf[3] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 5: ' & Round($Zeitbedarf[4] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 6: ' & Round($Zeitbedarf[5] / $Versuche, 6)*1000 & ' µs' & _
    @CRLF)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    For $_i = 0 To $Anz_Funktionen - 1
    $Zeitbedarf[$_i] = 0
    Next

    [/autoit] [autoit][/autoit] [autoit]

    $Schritte = Int(($Schritte+1)*$Multiplikator)

    [/autoit] [autoit][/autoit] [autoit]

    $Werte += 1

    [/autoit] [autoit][/autoit] [autoit]

    If $Letzte_Runde Then ExitLoop

    [/autoit] [autoit][/autoit] [autoit]

    If $Schritte > 2^31 - 1 Then
    $Schritte = 2^31 - 1
    $Letzte_Runde = True
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite('Erfasste Werte: ' & $Werte & @CRLF)
    EndFunc ;==>_Main

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_1($iDec) ; Divisionsmethode
    Local $sRet
    While Not $iDec = 0
    $iDec /= 2
    If IsInt($iDec) Then
    $sRet = '0' & $sRet
    Else
    $sRet = '1' & $sRet
    $iDec -= 0.5 ; Ohne den Rest gehts weiter
    EndIf
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_1

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_2($iDec) ; Subtraktionsmethode
    Local $sRet
    $iDec += 1
    For $i = Ceiling(Log($iDec) / Log(2)) To 0 Step -1
    If $iDec - 2 ^ $i > 0 Then
    $sRet &= '1'
    $iDec -= 2 ^ $i
    Else
    If $sRet Then $sRet &= '0'
    EndIf
    Next
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_2

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_3($iDec) ; Ausgedachte Methode 1
    Local $sHex = Hex($iDec), $sRet, $aBin[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    While StringLeft($sHex, 1) = '0'
    $sHex = StringTrimLeft($sHex, 1)
    WEnd
    For $i = 1 To StringLen($sHex) Step 1
    $sRet &= $aBin[Int('0x' & StringMid($sHex, $i, 1))]
    Next
    While StringLeft($sRet, 1) = '0'
    $sRet = StringTrimLeft($sRet, 1)
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_3

    [/autoit] [autoit][/autoit] [autoit]

    Func _IntToBin($Value); von BugFix
    Local $bin
    Do
    $bin = Mod($Value, 2) & $bin
    $Value = Int($Value / 2)
    Until $Value = 0
    Return $bin
    EndFunc ;==>_IntToBin

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_4($iD) ; Kombination von Methode 1 und 3 mit kleinen Optimierungen
    Local $sR
    If $iD < 65536 Then
    While Not $iD = 0
    $iD /= 2
    If IsInt($iD) Then
    $sR = '0' & $sR
    Else
    $sR = '1' & $sR
    $iD -= 0.5
    EndIf
    WEnd
    If Not $sR Then Return '0'
    Return $sR
    Else
    Local $sH = Hex($iD)
    Local Static $aB[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    While StringLeft($sH, 1) = '0'
    $sH = StringTrimLeft($sH, 1)
    WEnd
    For $i = 1 To StringLen($sH) Step 1
    $sR &= $aB[Int('0x' & StringMid($sH, $i, 1))]
    Next
    While StringLeft($sR, 1) = '0'
    $sR = StringTrimLeft($sR, 1)
    WEnd
    If Not $sR Then Return '0'
    Return $sR
    EndIf
    EndFunc ;==>_DecToBin_4

    [/autoit] [autoit][/autoit] [autoit]

    Func _IntToBin_2($iInt)
    Local $tChr = DllStructCreate('char[64]')
    DllCall($MSVCRT_Dll, 'ptr:cdecl', '_i64toa', 'int64', $iInt, 'ptr', DllStructGetPtr($tChr), 'int', 2)
    ;~ If @error Then Return SetError(1, 0, False)
    Return DllStructGetData($tChr, 1)
    EndFunc ;==>_IntToBin

    [/autoit]

    Ich habe aber schon eine Idee, wie evtl noch mehr rauszuholen ist. Mal sehen ons klappt^^

    lg
    Mars(i)

    Spoiler anzeigen

    [Blockierte Grafik: http://i.imgur.com/JHOIH.png]

    Edit:
    Habe grade versucht ein Array mit 256*256*256 Elementen zu machen.
    Das klappte auch wunderbar, bis AutoIt bei 2,04 GB Ramverbrauch ankam und Abbrach.
    WOZU braucht AutoIt 2GB bei 16.777.216 Elementen ? Das sind über 127KB/Element !

    Edit2:
    Wenn einem eine kleine Startzeit keine Umstände macht habe ich eine recht flotte Funktion gefunden.
    Es werden 2 Arrays mit Binärzahlen von 0 bis 256*256 gefüllt, ein Mal mit den vielen Nullen vorne und einmal ohne.
    Anschließend teilt man die mit Hex($iDec) bearbeitete Zahl in 2x 2Byte (2x 256*256).
    Anschließend wird nur noch das Array abgerufen.

    Ergebnis: Bei zahlen kleiner 256² dauert die Funktion nur 8 bis 9 µs (liegt weit unterhalb allem was wir bisher hatten)
    Ab 256² braucht die Funktion ca. 19-21 µs, und ist damit einen Schritt schneller als der DllCall.

    Nachteil: Eine Ladezeit von ca. 7 Sek bei volllast.

    Spoiler anzeigen
    [autoit]


    Global $MSVCRT_Dll = DllOpen('msvcrt.dll')
    Global $aOhneNull[256*256], $aMitNull[256*256]

    [/autoit] [autoit][/autoit] [autoit]

    For $i = 0 To 256*256 - 1 Step 1
    $aOhneNull[$i] = _IntToBin_2($i)
    $aMitNull[$i] = _DecToBin_3_Mit($i)
    Next

    [/autoit] [autoit][/autoit] [autoit]

    _Main()

    [/autoit] [autoit][/autoit] [autoit]

    DllClose($MSVCRT_Dll)

    [/autoit] [autoit][/autoit] [autoit]

    Func _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Local $Anz_Funktionen = 6
    Local $a[$Anz_Funktionen], $t, $r, $Zeitbedarf[$Anz_Funktionen], $Schritte = 0, $Letzte_Runde = False, $Werte = 0

    [/autoit] [autoit][/autoit] [autoit]

    Local $Versuche = 1500, $Excel = False, $Multiplikator = 1.25

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then Sleep(3000)

    [/autoit] [autoit][/autoit] [autoit]

    While $Schritte <= 2 ^ 31 - 1
    ConsoleWrite('Zahl: ' & $Schritte & @CRLF)
    If $Excel Then
    Send($Schritte, 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    EndIf
    For $i = 0 To $Versuche Step 1
    $r = $Schritte
    $t = TimerInit()
    $a[0] = _DecToBin_1($r) ; Divisionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[0] += $t
    $t = TimerInit()
    $a[1] = _DecToBin_2($r) ; Subtraktionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[1] += $t
    $t = TimerInit()
    $a[2] = _DecToBin_3($r) ; Arrayabruffunktion
    $t = TimerDiff($t)
    $Zeitbedarf[2] += $t
    $t = TimerInit()
    $a[3] = _IntToBin($r) ; Von Bugfix
    $t = TimerDiff($t)
    $Zeitbedarf[3] += $t
    $t = TimerInit()
    $a[4] = _DecToBin_4($r) ; Kombination der Divisionsmethode und der Ausgedachten.
    $t = TimerDiff($t)
    $Zeitbedarf[4] += $t
    $t = TimerInit()
    $a[5] = _IntToBin_2($r) ; Funktion mit DllCall
    $t = TimerDiff($t)
    $Zeitbedarf[5] += $t
    If ($a[0] <> $a[1]) Or ($a[0] <> $a[2]) Or ($a[0] <> $a[3]) Or ($a[0] <> $a[4]) Or ($a[0] <> $a[5]) Then ; Falls Abweichende Ergebnisse vorkommen ist eine Funktion falsch !
    ConsoleWrite('Error: ' & @CRLF & 'Int: ' & $r & @CRLF & ' 1.Bin: ' & $a[0] & _
    @CRLF & ' 2.Bin: ' & $a[1] & _
    @CRLF & ' 3.Bin: ' & $a[2] & _
    @CRLF & ' 4.Bin: ' & $a[3] & _
    @CRLF & ' 5.Bin: ' & $a[4] & _
    @CRLF & ' 6.Bin: ' & $a[5] & _
    @CRLF)
    ExitLoop
    EndIf
    Next

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then
    For $_i = 0 To $Anz_Funktionen - 1 Step 1
    Send(Round(($Zeitbedarf[$_i] / $Versuche) * 10000, 0), 1)
    Sleep(70)
    Send('{RIGHT}')
    Sleep(70)
    Next
    Send('{ENTER}')
    For $_i = 0 To $Anz_Funktionen Step 1
    Sleep(70)
    Send('{LEFT}')
    Next
    Else
    ConsoleWrite('Func 1: ' & Round($Zeitbedarf[0] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 2: ' & Round($Zeitbedarf[1] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 3: ' & Round($Zeitbedarf[2] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 4: ' & Round($Zeitbedarf[3] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 5: ' & Round($Zeitbedarf[4] / $Versuche, 6)*1000 & ' µs' & @CRLF & _
    'Func 6: ' & Round($Zeitbedarf[5] / $Versuche, 6)*1000 & ' µs' & _
    @CRLF)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    For $_i = 0 To $Anz_Funktionen - 1
    $Zeitbedarf[$_i] = 0
    Next

    [/autoit] [autoit][/autoit] [autoit]

    $Schritte = Int(($Schritte+1)*$Multiplikator)

    [/autoit] [autoit][/autoit] [autoit]

    $Werte += 1

    [/autoit] [autoit][/autoit] [autoit]

    If $Letzte_Runde Then ExitLoop

    [/autoit] [autoit][/autoit] [autoit]

    If $Schritte > 2^31 - 1 Then
    $Schritte = 2^31 - 1
    $Letzte_Runde = True
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite('Erfasste Werte: ' & $Werte & @CRLF)
    EndFunc ;==>_Main

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_1($iDec) ; Divisionsmethode
    Local $sRet
    While Not $iDec = 0
    $iDec /= 2
    If IsInt($iDec) Then
    $sRet = '0' & $sRet
    Else
    $sRet = '1' & $sRet
    $iDec -= 0.5 ; Ohne den Rest gehts weiter
    EndIf
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_1

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_2($iDec) ; Subtraktionsmethode
    Local $sRet
    $iDec += 1
    For $i = Ceiling(Log($iDec) / Log(2)) To 0 Step -1
    If $iDec - 2 ^ $i > 0 Then
    $sRet &= '1'
    $iDec -= 2 ^ $i
    Else
    If $sRet Then $sRet &= '0'
    EndIf
    Next
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_2

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_3($iDec) ; Ausgedachte Methode 2
    If $iDec < 65536 Then Return $aOhneNull[$iDec]
    Local $sHex = Hex($iDec)
    Return $aOhneNull[Int('0x' & StringLeft($sHex, 4))] & $aMitNull[Int('0x' & StringRight($sHex, 4))]
    EndFunc ;==>_DecToBin_3

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_3_Mit($iDec) ; Ausgedachte Methode 1
    Local $sHex = Hex($iDec), $sRet, $aBin[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    For $i = 1 To 8 Step 1
    $sRet &= $aBin[Int('0x' & StringMid($sHex, $i, 1))]
    Next
    If Not $sRet Then Return '0'
    Return StringRight($sRet, 16)
    EndFunc ;==>_DecToBin_3

    [/autoit] [autoit][/autoit] [autoit]

    Func _IntToBin($Value); von BugFix
    Local $bin
    Do
    $bin = Mod($Value, 2) & $bin
    $Value = Int($Value / 2)
    Until $Value = 0
    Return $bin
    EndFunc ;==>_IntToBin

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_4($iD) ; Kombination von Methode 1 und 3 mit kleinen Optimierungen
    Local $sR
    If $iD < 65536 Then
    While Not $iD = 0
    $iD /= 2
    If IsInt($iD) Then
    $sR = '0' & $sR
    Else
    $sR = '1' & $sR
    $iD -= 0.5
    EndIf
    WEnd
    If Not $sR Then Return '0'
    Return $sR
    Else
    Local $sH = Hex($iD)
    Local Static $aB[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    While StringLeft($sH, 1) = '0'
    $sH = StringTrimLeft($sH, 1)
    WEnd
    For $i = 1 To StringLen($sH) Step 1
    $sR &= $aB[Int('0x' & StringMid($sH, $i, 1))]
    Next
    While StringLeft($sR, 1) = '0'
    $sR = StringTrimLeft($sR, 1)
    WEnd
    If Not $sR Then Return '0'
    Return $sR
    EndIf
    EndFunc ;==>_DecToBin_4

    [/autoit] [autoit][/autoit] [autoit]

    Func _IntToBin_2($iInt)
    Local $tChr = DllStructCreate('char[64]')
    DllCall($MSVCRT_Dll, 'ptr:cdecl', '_i64toa', 'int64', $iInt, 'ptr', DllStructGetPtr($tChr), 'int', 2)
    ;~ If @error Then Return SetError(1, 0, False)
    Return DllStructGetData($tChr, 1)
    EndFunc ;==>_IntToBin

    [/autoit]
    Spoiler anzeigen

    [Blockierte Grafik: http://i.imgur.com/CFAYA.png]Y-Skalierung: 0.1 µs

  • Suche (schnelle) Funktion zum Umrechnen ins Dual- oder Hexadezimalsystem

    • Mars
    • 30. August 2011 um 23:32

    Weil ich jetzt nicht so viel Zeit habe Abends habe ich den Spaß mal mit "nur" 1000 Versuchen durchlaufen lassen.

    Was die Textmenge angeht ist Bugfix' Version deutlich kleiner, Geschwindigkeitsmäßig kommt sie aber gegen die Divisionsmethode nicht an.
    (ich verstehe aber eigentlich nicht warum, da sie ja nichts anderes als diese tut...)

    Der Zahlenraum der Gemessen wird ist jetzt von 0 bis 2^31 - 1. (Vorher hat das Prog den Letzten Wert immer unterschlagen.)

    Code
    [autoit][/autoit] [autoit][/autoit] [autoit]

    _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Func _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Local $Anz_Funktionen = 4
    Local $a[$Anz_Funktionen], $t, $r, $Zeitbedarf[$Anz_Funktionen], $Versuche = 1000, $Schritte = 0
    Local $Excel = False, $Letzte_Runde = False

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then Sleep(3000)

    [/autoit] [autoit][/autoit] [autoit]

    While $Schritte <= 2 ^ 31 - 1
    ConsoleWrite('Zahl: ' & $Schritte & @CRLF)
    If $Excel Then
    Send($Schritte, 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    EndIf
    For $i = 0 To $Versuche Step 1
    $r = $Schritte
    $t = TimerInit()
    $a[0] = _DecToBin_1($r) ; Divisionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[0] += $t
    $t = TimerInit()
    $a[1] = _DecToBin_2($r) ; Subtraktionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[1] += $t
    $t = TimerInit()
    $a[2] = _DecToBin_3($r) ; Ausgedacht 1
    $t = TimerDiff($t)
    $Zeitbedarf[2] += $t
    $t = TimerInit()
    $a[3] = _IntToBin($r) ; Von Bugfix
    $t = TimerDiff($t)
    $Zeitbedarf[3] += $t
    If ($a[0] <> $a[1]) Or ($a[0] <> $a[2]) Or ($a[0] <> $a[3]) Then ; Falls Abweichende Ergebnisse vorkommen ist eine Funktion falsch !
    ConsoleWrite('Error: ' & @CRLF & 'Int: ' & $r & @CRLF & ' 1.Bin: ' & $a[0] & @CRLF & ' 2.Bin: ' & $a[1] & @CRLF & ' 3.Bin: ' & $a[2] & @CRLF & ' 4.Bin: ' & $a[3] & @CRLF)
    EndIf
    Next

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then
    For $_i = 0 To $Anz_Funktionen - 1 Step 1
    Send(Round(($Zeitbedarf[$_i] / $Versuche) * 1000, 0), 1)
    Sleep(70)
    Send('{RIGHT}')
    Sleep(70)
    Next
    Send('{ENTER}')
    For $_i = 0 To $Anz_Funktionen Step 1
    Sleep(70)
    Send('{LEFT}')
    Next
    Else
    ConsoleWrite('Func 1: ' & Round($Zeitbedarf[0] / $Versuche, 5) & ' ms' & @CRLF & 'Func 2: ' & Round($Zeitbedarf[1] / $Versuche, 5) & ' ms' & @CRLF & 'Func 3: ' & Round($Zeitbedarf[2] / $Versuche, 5) & ' ms' & @CRLF & 'Func 4: ' & Round($Zeitbedarf[3] / $Versuche, 5) & ' ms' & @CRLF)
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    For $_i = 0 To $Anz_Funktionen - 1
    $Zeitbedarf[$_i] = 0
    Next

    [/autoit] [autoit][/autoit] [autoit]

    $Schritte += 1
    $Schritte *= 1.4
    $Schritte = Int($Schritte)

    [/autoit] [autoit][/autoit] [autoit]

    If $Letzte_Runde Then ExitLoop

    [/autoit] [autoit][/autoit] [autoit]

    If $Schritte > 2^31 - 1 Then
    $Schritte = 2^31 - 1
    $Letzte_Runde = True
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    WEnd
    EndFunc ;==>_Main

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_1($iDec) ; Divisionsmethode
    Local $sRet
    While Not $iDec = 0
    $iDec /= 2
    If IsInt($iDec) Then
    $sRet = '0' & $sRet
    Else
    $sRet = '1' & $sRet
    $iDec -= 0.5 ; Ohne den Rest gehts weiter
    EndIf
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_1

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_2($iDec) ; Subtraktionsmethode
    Local $sRet
    $iDec += 1
    For $i = Ceiling(Log($iDec) / Log(2)) To 0 Step -1
    If $iDec - 2 ^ $i > 0 Then
    $sRet &= '1'
    $iDec -= 2 ^ $i
    Else
    If $sRet Then $sRet &= '0'
    EndIf
    Next
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_2

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_3($iDec) ; Ausgedachte Methode 1
    Local $sHex = Hex($iDec), $sRet, $aBin[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    While StringLeft($sHex, 1) = '0'
    $sHex = StringTrimLeft($sHex, 1)
    WEnd
    For $i = 1 To StringLen($sHex) Step 1
    $sRet &= $aBin[Int('0x' & StringMid($sHex, $i, 1))]
    Next
    While StringLeft($sRet, 1) = '0'
    $sRet = StringTrimLeft($sRet, 1)
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_3

    [/autoit] [autoit][/autoit] [autoit]

    Func _IntToBin($Value); von BugFix
    Local $bin
    Do
    $bin = Mod($Value, 2) & $bin
    $Value = Int($Value / 2)
    Until $Value = 0
    Return $bin
    EndFunc ;==>_IntToBin

    [/autoit]
    Diagramm

    [Blockierte Grafik: http://i.imgur.com/lkCOC.png]

    Wenn man alle Funktionen kombiniert (mittels der eingangszahl zur jeweils dafür schnellsten Funktion switcht) müsste sich eine Funktion bauen lassen die immer knapp oberhalb der bisherigen Bestzeiten liegt.

    lg
    Mars(i)

  • Suche (schnelle) Funktion zum Umrechnen ins Dual- oder Hexadezimalsystem

    • Mars
    • 30. August 2011 um 17:29

    Moin,
    Das eigentliche Thema wurde bereits zufriedenstellend gelöst (eine sehr Schnelle Methode ist in Post 15 zu finden), nun gibt es leider ein weiteres Problem mit Dezimal und Dualzahlen (oder Hexadezimalzahlen).

    -----------------------------------------------------------------------------------------------
    Ich stehle hiermit mal meinen eigenen Thread und ändere das Thema leicht ab.

    Es geht jetzt um Folgendes:
    Suche (schnelle) Funktion zum umrechnen ins Dual- oder Hexadezimalsystem
    Problemstellung:
    Mein Arithmetischer Kodierer spuckt mir einen String im Dezimalsystem entgegen. Dieser String enthält je nach Input hunderte bis zehntausende Zahlen. Um diesen Spaß anständig zu speichern wird er im Dualsystem gebraucht. (Der Header der daraus entstehenden "Datei" ist im Dualsystem, da einzelne Bits entscheidend sind, die Kodierung der Wahrscheinlichkeiten ist im Dualsystem usw usw. Also muss auch der kodierte String ins Dualsystem. Dann schön alles zusammensetzen und als Binary zurückgeben)

    Wie funktioniert soetwas ?
    Der Ansatz mit den hier diskutierten Methoden läuft jedenfalls nicht, da man nicht jedes Mal die komplette endlos lange Dezimalzahl durch 2 Teilen kann. Die Subtraktionsmethode fällt ebenfalls flach, da man nicht immer mit so enormen Zahlen potenzieren kann und anschließend 2 riesige Zeichenketten voneinander abziehen kann. Die restlichen Methoden bauen darauf auf die Dezimalzahl erstmal per Hex zu verarbeiten, sodass weitere Schritte sehr einfach sind; läuft bei großen Zahlen auch nicht.

    Ich bitte daher um einen Ansatz, wie man eine große Dezimalzahl stück für Stück umwandeln kann.

    Edit:

    Funktion für kleine Zahlen (&lt; 2^31)
    [autoit]

    Global $a_[256], $b_[256], $c_[11111112]

    [/autoit] [autoit][/autoit] [autoit]

    _DecToBin_Startup()

    [/autoit] [autoit][/autoit] [autoit]

    Global $sDec = '123456789'
    Global $sBin = _DecToBin($sDec)
    Global $sDec2 = _BinToDec($sBin)

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite('Original: ' & $sDec & @CRLF & 'Binär: ' & $sBin & @CRLF & 'Dezimal: ' & $sDec2 & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ; <Func>--------------------------------------------------|
    ; Wandelt eine Dualzahl in eine Dezimalzahl um |
    ; --------------------------------------------------------|
    Func _BinToDec($s)
    Local $l = StringLen($s)
    Return $l<9?$c_[$s]:$l<17?$c_[StringTrimRight($s,8)]*256+$c_[StringRight($s,8)]:$l<25?$c_[StringTrimRight($s,16)]*65536+$c_[StringRight(StringTrimRight($s,8),8)]*256+ $c_[StringRight($s,8)]:BitShift($c_[StringTrimRight($s,24)],-24)+$c_[StringRight(StringTrimRight($s,16),8)]*65536+$c_[StringRight(StringTrimRight($s,8),8)]*256+$c_[StringRight($s,8)]
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; <Func>--------------------------------------------------|
    ; Ermittelt eine Dualzahl (0101) aus einer Dezimalzahl |
    ; Die Dezimalzahl muss kleiner als 2^31 sein |
    ; --------------------------------------------------------|
    Func _DecToBin($d)
    Return $d<256?$a_[$d]:$d<65536?$a_[$d/256]&$b_[BitAND($d,255)]:$d<16777216?$a_[$d/65536]&$b_[BitAND($d/256,255)]&$b_[BitAND($d,255)]:$a_[BitShift($d,24)]&$b_[BitAND($d/65536,255)]&$b_[BitAND($d/256,255)]&$b_[BitAND($d,255)]
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; <Func>--------------------------------------------------|
    ; Initialisiert die DecToBin UDF |
    ; --------------------------------------------------------|
    Func _DecToBin_Startup()
    Local $t = DllStructCreate('char[64]'), $p = _
    DllStructGetPtr($t), $hDll = DllOpen('msvcrt.dll')
    For $i = 0 To 255 Step 1
    DllCall($hDll, 'ptr:cdecl', '_i64toa', 'int64', _
    $i, 'ptr', $p, 'int', 2)
    $a_[$i] = DllStructGetData($t, 1)
    $b_[$i] = StringRight('0000000' & $a_[$i], 8)
    $c_[$a_[$i]] = $i
    Next
    DllClose($hDll)
    EndFunc

    [/autoit]
    Funktion für beliebig große Strings
    [autoit]


    ; Sämtlicher Code ist von Make-Grafik.

    [/autoit] [autoit][/autoit] [autoit]

    Global $sDec = '1234567890123456789012345678901234567890'
    Global $sHex = _Big_DecToHex($sDec)
    Global $sDec2 = _Big_HexToDec($sHex)

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite('Original: ' & $sDec & @CRLF & 'Hexadezimal: ' & StringTrimLeft($sHex, 2) & @CRLF & 'Dezimal: ' & $sDec2 & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    Func _Big_DecToHex($sInteger)
    Local $i, $bp, $carry, $n, $aiInt[1], $product
    For $i = 1 To StringLen($sInteger)
    $bp = 0
    $carry = StringMid($sInteger, $i, 1)
    For $n = 0 To UBound($aiInt) -1
    $product = $aiInt[$n] & $carry
    $aiInt[$bp] = BitAND($product, 0x00FF)
    $carry = BitAND($product, 0xFF00) / 0x0100
    $bp += 1
    Next
    If $carry Then
    ReDim $aiInt[$bp +1]
    $aiInt[$bp] = $carry
    EndIf
    Next
    Return StringToBinary(StringFromASCIIArray($aiInt, 0, Default, 1))
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _Big_HexToDec($aiInt)
    $aiInt = StringToASCIIArray(BinaryToString($aiInt), 0, Default, 1)
    Local $carry, $i, $product, $sInteger
    Local $index = UBound($aiInt) -1
    Do
    $carry = StringRight($aiInt[$index], 1)
    $aiInt[$index] = Floor($aiInt[$index] / 10)
    For $i = $index -1 To 0 Step -1
    $product = $carry * 0x0100 + $aiInt[$i]
    $aiInt[$i] = Floor($product / 10)
    $carry = StringRight($product, 1)
    Next
    $sInteger &= $carry
    If Not $aiInt[$index] Then
    ReDim $aiInt[$index]
    $index -= 1
    EndIf
    Until $index = -1
    Return StringReverse($sInteger)
    EndFunc

    [/autoit]


    Eine ASM Version von DecToBin (kann auch in Hex oder Str umwandeln) gibts von eukalyptus in Post36

    lg
    M
    -----------------------------------------------------------------------------------------------

    Originaler Inhalt des #1 Post


    Moin

    Geschwindigkeit ist wie immer König im Haus.
    Es geht um die Umrechnung von 32Bit Ganzzahlen (int) ins Dualsystem (0101010)
    Aus Wikipedia habe ich die Divisions und die Subtraktions-Methode angesehen und festgestellt, dass diese in AutoIt auch wunderbar funktionieren.

    Problematisch wird es nun bei wirklich großen Zahlen. Da dauert der Aufruf schonmal 0.14 ms wenn man sich auf diese Methoden stützt.
    Also habe ich etwas gebastelt und eine Methode entdeckt, mit der der Spaß immer nahezu konstant in 0.08ms erledigt wird. (Fast doppelt so schnell)
    (logisch, eigentlich sind die anderen Methoden weitaus schneller, aber in AutoIt ist die Welt eben manchmal verkehrt^^)

    Bei kleinen Zahlen ist diese Methode den Wikipediamethoden weit unterlegen (Faktor ca. 4:1), bei großen Zahlen aber überlegen.

    Jetzt interessiert es mich, falls jemand hier ab und zu mal sowas nutzt, welche Funktion für die Umwandlung benutzt wird und wie schnell diese ist.

    Gesucht wird die schnellste Funktion die eine beliebige 32Bit Int Zahl ins Dualsystem (010101) bringt.
    Dabei muss keine Rücksicht auf nativen AutoIt Code genommen werden. Sollte es eine Dll-Func geben die ich nicht kenne bin ich natürlich erfreut mit dieser Bekanntschaft zu machen :)

    Code
    [autoit][/autoit] [autoit][/autoit] [autoit]

    _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Func _Main()

    [/autoit] [autoit][/autoit] [autoit]

    Local $a[3], $t, $r, $Zeitbedarf[3], $Versuche = 5000, $Schritte = 0
    Local $Excel = False

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then Sleep(5000)

    [/autoit] [autoit][/autoit] [autoit]

    While $Schritte < 2 ^ 31 - 1
    ConsoleWrite('Zahl: ' & $Schritte & @CRLF)
    If $Excel Then
    Send($Schritte, 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    EndIf
    For $i = 0 To $Versuche Step 1
    $r = $Schritte
    $t = TimerInit()
    $a[0] = _DecToBin_1($r) ; Divisionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[0] += $t
    $t = TimerInit()
    $a[1] = _DecToBin_2($r) ; Subtraktionsmethode
    $t = TimerDiff($t)
    $Zeitbedarf[1] += $t
    $t = TimerInit()
    $a[2] = _DecToBin_3($r) ; Ausgedacht 1
    $t = TimerDiff($t)
    $Zeitbedarf[2] += $t
    If ($a[0] <> $a[1]) Or ($a[0] <> $a[2]) Then
    ConsoleWrite('Error: ' & @CRLF & 'Int: ' & $r & @CRLF & ' 1.Bin: ' & $a[0] & @CRLF & ' 2.Bin: ' & $a[1] & @CRLF & ' 3.Bin: ' & $a[2])
    EndIf
    Next

    [/autoit] [autoit][/autoit] [autoit]

    If $Excel Then
    Send(Round(($Zeitbedarf[0] / $Versuche) * 1000, 0), 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    Send(Round(($Zeitbedarf[1] / $Versuche) * 1000, 0), 1)
    Sleep(100)
    Send('{RIGHT}')
    Sleep(100)
    Send(Round(($Zeitbedarf[2] / $Versuche) * 1000, 0), 1)
    Sleep(100)
    Send('{ENTER}')
    Sleep(100)
    Send('{LEFT}')
    Sleep(100)
    Send('{LEFT}')
    Sleep(100)
    Send('{LEFT}')
    Sleep(100)
    Else
    ConsoleWrite('Func 1: ' & Round($Zeitbedarf[0] / $Versuche, 5) & ' ms' & @CRLF & 'Func 2: ' & Round($Zeitbedarf[1] / $Versuche, 5) & ' ms' & @CRLF & 'Func 3: ' & Round($Zeitbedarf[2] / $Versuche, 5) & ' ms' & @CRLF)
    EndIf
    $Zeitbedarf[0] = 0
    $Zeitbedarf[1] = 0
    $Zeitbedarf[2] = 0

    [/autoit] [autoit][/autoit] [autoit]

    $Schritte += 1
    $Schritte *= 1.5
    $Schritte = Int($Schritte)

    [/autoit] [autoit][/autoit] [autoit]

    WEnd
    EndFunc ;==>_Main

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_1($iDec) ; Divisionsmethode
    Local $sRet
    While Not $iDec = 0
    $iDec /= 2
    If IsInt($iDec) Then
    $sRet = '0' & $sRet
    Else
    $sRet = '1' & $sRet
    $iDec -= 0.5 ; Ohne den Rest gehts weiter
    EndIf
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_1

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_2($iDec) ; Subtraktionsmethode
    Local $sRet
    $iDec += 1
    For $i = Ceiling(Log($iDec) / Log(2)) To 0 Step -1
    If $iDec - 2 ^ $i > 0 Then
    $sRet &= '1'
    $iDec -= 2 ^ $i
    Else
    If $sRet Then $sRet &= '0'
    EndIf
    Next
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_2

    [/autoit] [autoit][/autoit] [autoit]

    Func _DecToBin_3($iDec) ; Ausgedachte Methode 1
    Local $sHex = Hex($iDec), $sRet, $aBin[16] = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']
    While StringLeft($sHex, 1) = '0'
    $sHex = StringTrimLeft($sHex, 1)
    WEnd
    For $i = 1 To StringLen($sHex) Step 1
    $sRet &= $aBin[Int('0x' & StringMid($sHex, $i, 1))]
    Next
    While StringLeft($sRet, 1) = '0'
    $sRet = StringTrimLeft($sRet, 1)
    WEnd
    If Not $sRet Then Return '0'
    Return $sRet
    EndFunc ;==>_DecToBin_3

    [/autoit]


    Anbei eine kleine Tabelle mit einem Geschwindigkeitsvergleich.

    Hier drin

    [Blockierte Grafik: http://i.imgur.com/QEjhm.png]

    lg
    Mars(i)


    -----------------------------------------------------------------------------------------------

  • au15k - Skriptwettbewerb - Fertig -

    • Mars
    • 22. August 2011 um 21:04

    Ich würde mal Vorschlagen (da keine großen Umschwünge des Meinungsbildes mehr zu erwarten sind), dass wir hier das Licht ausmachen.

    Der Sieger steht ja wohl eindeutig fest :P

    lg
    Mars(i)

  • PC friert einfach ein

    • Mars
    • 22. August 2011 um 20:56

    80 Grad ist für einen Rechner bedeutend zu viel !

    Selbst bei Volllast sollte die 70 nicht überschritten werden.
    Im Leerlauf sind 25 Grad über Raumtemp ok, viel mehr aber auch nicht.

    Bios schaltet dann automatisch den PC ab, wenn es zu heiß wird (ist mir mal passiert wo ich den PC übertaktet hatte und es wieder Sommer wurde. Dann steigt bekanntlich die Raumtemp von ca. 15 auf 25-35 (ich wohne unterm Dach und hab keine Klimaanlage) und damit ging die Prozessortemparatur auch um ca. 15° nach oben.)

    Wenn man dennoch weitermachen will (kann ich aber nicht empfehlen) kann man bei vielen Systemen im Bios die Abschaltbedingungen anpassen oder gar ausstellen.

    Wer seine temparatur angezeigt haben will kann auf tools wie z.B. Real Temp zurückgreifen. Nicht optimal genau, aber immerhin ein grober Abriss (+- 10%)
    http://www.chip.de/downloads/Real-Temp_43638018.html

    lg
    Mars(i)

  • ImageUDF 1

    • Mars
    • 16. August 2011 um 22:11

    Beim Zeichnen der Vierecke scheitert die ImageUDF leider kläglich. (Es ist zwar möglich, dauert aber länger als ein gleich großes Bild zu zeichnen^^)

    (Angaben in ms)
    ;Alles ; 1x Clear, 2xViereck, 3xBild (Bilder: 1x Großes Logo, 1x Kleines Logo, 1x Backbuffer auf Backbuffer2)
    ;2.45 - ImageUDF ; 3x Viereck, da der Clear in Asm sein wird und noch nicht eingebaut ist.
    ;2.35 - GDI+

    ;Bilder+Clear ; 1xClear, 3xBild (Bilder: 1x Großes Logo, 1x Kleines Logo, 1x Backbuffer auf Backbuffer2)
    ;1.45 - ImageUDF
    ;1.75 - GDI+

    ;Bilder ; 3xBild (Bilder: 1x Großes Logo, 1x Kleines Logo, 1x Backbuffer auf Backbuffer2)
    ;0.49 - ImageUDF
    ;1.20 - GDI+

    ;Bilder ; 3xBild (Bilder: 1x Großes Logo (skaliert auf 160x160), 1x Kleines Logo(auf 40x40), 1x Backbuffer auf Backbuffer2)
    ;0.58 - ImageUDF
    ;1.55 - GDI+

    Wenn es nur um Bilder geht ist die ImageUDF mehr als doppelt so schnell.
    Sachen wie Clear oder Rechtecke füllen werden später als Inlineasm eingebaut. Dann geht auch das schneller als GDI+

    Edit: Wenn man als Clear ein BitBlt mit Blackness nutzt (dann geht halt nur schwarz/transparent, aber keine Farbigen clears) kommt man beim. 1xClear, 3xBild auf 0.67ms.. Allein der Funktionsaufruf um das DC zu bkeommen dauert etwa 0.07ms. Speichert man das DC in einer Variable ab kommt man auf ca. 0.6ms.

    lg
    Mars(i)

  • ImageUDF 1

    • Mars
    • 16. August 2011 um 20:56

    Moin,

    Ich möchte euch hier das vorstellen, was über einige Wochen und Monate nebenher entstanden ist. Die ImageUDF.

    Wie der Name schon sagt geht es um Bilder (Nicht um Linien, Kreise oder Vektoren).
    Das Augenmerk liegt auf der Ausführgeschwindigkeit(beim Zeichnen) und der einfachen Anwendung der Funktionen.
    (Im Gegensatz zu purer GDI+ Anwendung, wo die Geschwindigkeit beim Zeichnen (von Bildern) oft auf der Strecke bleibt)

    Es wird z.B. um ein einfarbiges Viereck zu füllen keine Brush oder sonstiges benötigt die wieder handles hat und Variablen braucht, sondern nur die Farbe.

    Um Bilder zu erzeugen wird eine Hand voll Funktionen geliefert, sodass man leere Bilder erzeugen kann, Bilder aus Ressourcen laden kann oder von Dateien.

    Zum Zeichnen werden die WinAPI-Funktionen genutzt. Daher kommt auch die relativ hohe Geschwindigkeit.

    Ein $Image besteht aus mehreren Komponenten, damit man z.B. die Breite nicht erst über einen DllCall(das kostet Zeit) ermitteln muss. Enthalten sind:
    1. hDC
    2. Breite
    3. Höhe
    4. Ptr (für die Bitmapdaten im Ram)
    5. HBMP
    Diese werden in einer Struct gesichert, was auch die Arraylagerung ermöglicht. ( ein Array für alle Bilder die in einem Programm genutzt werden. Anschließend kann man einfach eine Schleife durchlaufen lassen um alle zu löschen. )

    Die ImageUDF ist somit ein Wrapper für GDI(+) und WinAPI Funktionen die somit leichter zu Verwenden sein sollen.

    Noch ist die UDF erst der "kleine Anfang" von etwas Größerem.
    Noch geplant ist Assemblernutzung und Prozedurale Grafikerzeugung. (evtl auch OpenCL nutzung)

    Zum Zeichnen ist zu sagen:

    Funktionen mit einem "Draw" ignorieren die Transparenz, jene mit einem "Blend" erhalten sie. (Wer also Etwas mit transparenten Teilen Zeichnen will sollte immer die Blend Funktionen nutzen)

    Wer tatsächlich alle Parameter vom BitBlt / AlphaBlend ausnutzen will sollte die Funktion direkt aufrufen und nicht über die Wrapperfunktoinen. Diese sollen das "einfache" verwenden vereinfachen. _Image_Draw hat z.B. nur 4 Parameter, DC, X, Y, Img. Damit muss man nicht immer alle 8 oder mehr Parameter ausfüllen und erhält wesentlich mehr übersichtlichkeit im Code.

    Alle "Draw" Funktionen haben ein "Blend" Gegenstück. Sollte man nachträglich etwas Transparentes nutzen reicht die Änderung eines Wortes um alles umzustellen.

    Ich hoffe alles so kommentiert zu haben, wie es sich gehört und hoffe, dass ihr damit etwas anfangen könnt.
    Anbei ist auch eine kleine Demonstration. (Klar kann man das alles auch per GDI+ machen...)

    Für Verbesserungen und Vorschläge bin ich offen :P

    lg
    Mars(i)

    Dateien

    ImageUDF(1) + Beispiel.rar 40,38 kB – 321 Downloads
  • Bomberman

    • Mars
    • 15. August 2011 um 19:53

    Ich meinte damit, sobald GDI+ verwendet wird sind png Grafiken auf jeden Fall besser.
    (sowohl in der Qualität, als auch im Speicherverbrauch. Es erhöht natürlich nicht die Qualität jetzt den Typ zu ändern. Dazu müsste man das bild nochmal komplett neu machen als png eben^^)
    (Wusste garnicht, dass man mit guictrlcreatepic kein png laden kann. ich arbeite damit nie^^)

    lg
    Mars(i)

  • Bomberman

    • Mars
    • 15. August 2011 um 17:54

    Moin,

    Jetzt klappt alles, allerdings ist das Spiel noch etwas "roh".
    Mit QuickDraw oder ähmlichem zu arbeiten halte ich für Anfänger für keine gute Idee, da man dafür eine Extra Dll braucht und die Befehle nicht so gut bekannt sind wie die "standard" GDI+ Befehle.

    Bilder sind in den Größen im .Png Format wesentlich besser als im jpg Format. (es sind ja Computergrafiken und keine Fotorealistischen Bilder in hoher Auflösung).

    Zuerst sollte aber das Spielprinzip funktionieren.
    - Extras in gesprengten Kisten
    - Explosionen gehen nicht mehr duch Wände, sondern sprengen immer nur den Vordersten Klotz
    - Balancing (Bomben Explodieren viel zu schnell z.B.)
    - Mehr Bomben legen als eine
    - usw

    lg
    Mars(i)

  • Bomberman

    • Mars
    • 14. August 2011 um 22:29

    Ich kanns leider nicht runterladen. (bei mir bricht der Download immer ab nach ein paar Minuten).
    Sieht aber vom Screen und Code schonmal recht vielversprechend aus.

    Die Grafik sollte man sowieso erst machen, wenn das Spiel ansich schonmal funktioniert.

    Ich versuch noch ein bisschen die Datei zu bekommen.....

    lg
    Mars(i)

  • überlanges Array

    • Mars
    • 14. August 2011 um 17:12
    [autoit]

    Local $Array[1000] = [999, 888, 777, _
    666, 555, 444, 333, _
    222, 111, -111]

    [/autoit]

    Man kann mit dem Unterstrich fast alles in AutoIt trennen, so auch Arrays.

    lg
    Mars(i)

  • Grafik(en) in *.exe einbinden ohne Fileinstall

    • Mars
    • 10. August 2011 um 22:33

    Das problem kann man auch folgendermaßen geschickt umgehen.

    Im Beispiel Enthalten: 2 Bilder:
    1. als Komprimierte Ressource (So siehts nach dem Komprimieren aus)
    2. Als direkte Ressource.

    Die Bilder werden mittels _CreateImageRes geladen (ok, dabei wird eigentlich schon viel zu viel gemacht, aber ich wollte die UDF Funktionen nicht zerlegen...), in für GDI+ verträgliche Formate gebracht und abgebildet.

    Ressourcen von Dateien kann man hiermit holen (und bei Bedarf komprimieren):
    ( Komprimieren dauert bei Größeren Sachen Ewig. Deshalb lieber erstmal mit kleinen Bildern die Funktionalität Testen. Das Tool hab ich heute aus Spaß mal geschrieben und hier findet es direkt Verwendung^^)

    Spoiler anzeigen
    [autoit][/autoit] [autoit][/autoit] [autoit]

    Global $Direkter_Pfad = False
    If $cmdline[0] Then $Direkter_Pfad = $cmdline[1]

    [/autoit] [autoit][/autoit] [autoit]

    Opt('GUICloseOnESC', 0)
    Opt('GUIOnEventMode', 1)

    [/autoit] [autoit][/autoit] [autoit]

    Global $StringLaenge_ = 4000

    [/autoit] [autoit][/autoit] [autoit]

    Global $hGUI = GUICreate('Datei zu Ressource', 330, 55)
    GUISetOnEvent(-3, '_Exit', $hGUI)
    Global $hButton = GUICtrlCreateButton('Aktion', 0, 0, 100, 30)
    GUICtrlSetOnEvent(-1, '_FileToRes2')
    Global $hLabel = GUICtrlCreateLabel('Keine Aktion...', 100, 8, 140, 32, 1)
    Global $hCheckBox = GUICtrlCreateCheckbox('Komprimieren', 245, 4)
    Global $hSlider = GUICtrlCreateSlider(0, 30, 330, 25)
    GUICtrlSetOnEvent(-1, '_Slider')
    GUICtrlSetLimit(-1, 4000, 20)

    [/autoit] [autoit][/autoit] [autoit]

    GUICtrlSetData($hSlider, 4000)
    GUICtrlSetState($hCheckBox, 1)

    [/autoit] [autoit][/autoit] [autoit]

    GUISetState(@SW_SHOW)

    [/autoit] [autoit][/autoit] [autoit]

    If $Direkter_Pfad Then
    _FileToRes($Direkter_Pfad, 'ZielUnnötig.txt')
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    While Sleep(20)
    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    Func _Exit()
    Exit
    EndFunc ;==>_Exit

    [/autoit] [autoit][/autoit] [autoit]

    Func _Slider()
    Local Static $Read_Alt
    Local $Read = GUICtrlRead($hSlider)
    If $Read <> $Read_Alt Then
    $Read_Alt = $Read
    GUICtrlSetData($hLabel, 'Stringlänge: ' & $Read)
    $StringLaenge_ = $Read
    EndIf
    EndFunc ;==>_Slider

    [/autoit] [autoit][/autoit] [autoit]

    Func _FileToRes2()
    _FileToRes()
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _UnBlock($a = 0)
    GUICtrlSetState($hButton, 64)
    GUICtrlSetState($hCheckBox, 64)
    GUICtrlSetState($hSlider, 64)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _Block()
    GUICtrlSetState($hButton, 128)
    GUICtrlSetState($hCheckBox, 128)
    GUICtrlSetState($hSlider, 128)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _FileToRes($Quell_Pfad = False, $Ziel_Pfad = False)
    _Block()
    Local $Read, $Len_Alt, $Ressource, $Len_Neu

    [/autoit] [autoit][/autoit] [autoit]

    If Not $Quell_Pfad Then $Quell_Pfad = FileOpenDialog('Datei wählen', @ScriptDir, 'Bilder (*.jpg;*.png;*.gif;*.bmp;*.*)')
    If $Quell_Pfad = '' Then Return _UnBlock(GUICtrlSetData($hLabel, 'Keine gültige Quelle'))
    If Not $Ziel_Pfad Then $Ziel_Pfad = FileSaveDialog('Ziel wählen', @ScriptDir, 'Res (*.txt;*.res;*.*)')
    If $Ziel_Pfad = "" Then Return _UnBlock(GUICtrlSetData($hLabel, 'Kein gültiges Ziel'))
    GUICtrlSetData($hLabel, 'Datei wird geöffnet...')
    $Read = FileRead($Quell_Pfad)
    $Len_Alt = StringLen($Read)

    [/autoit] [autoit][/autoit] [autoit]

    If GUICtrlRead($hCheckBox) = 1 Then
    GUICtrlSetData($hLabel, 'Versuch mit LZ77...')
    $Ressource = _Ersetzung_Comp('1' & _LZ77_4096_16_Comp($Read)) ; Beginn ist eine 1 -> LZ77
    ConsoleWrite('LZ77: ' & Int(100 * (StringLen($Ressource)+1) / $Len_Alt) & ' %' & @CRLF)
    GUICtrlSetData($hLabel, 'Versuch ohne LZ77...')
    $Read = _Ersetzung_Comp('0' & StringTrimLeft(StringToBinary($Read), 2)) ; Beginn ist eine 0 -> Kein LZ77
    ConsoleWrite('Normal: ' & Int(100 * (StringLen($Read)+1) / $Len_Alt) & ' %' & @CRLF)
    If StringLen($Ressource) > StringLen($Read) Then $Ressource = $Read ; Wenn LZ77 größer -> Verwerfen wir die Arbeit !
    Else
    $Ressource = StringToBinary($Read)
    EndIf
    $Len_Neu = StringLen($Ressource)
    GUICtrlSetData($hLabel, 'Datei wird geschrieben...')
    If $Direkter_Pfad Then
    ClipPut(_Trennung($Ressource, $StringLaenge_))
    GUICtrlSetData($hLabel, 'Kompression: ' & Int(100 * ($Len_Neu+1) / $Len_Alt) & ' %')
    Sleep(1500)
    Exit
    EndIf
    FileWrite($Ziel_Pfad, _Trennung($Ressource, $StringLaenge_))
    GUICtrlSetData($hLabel, 'Datei geschrieben...')
    Sleep(500)
    GUICtrlSetData($hLabel, 'Kompression: ' & Int(100 * ($Len_Neu+1) / $Len_Alt) & ' %')
    _UnBlock()
    EndFunc ;==>_DateiToRes

    [/autoit] [autoit][/autoit] [autoit]

    Func _Trennung($String, $n = 100)
    Local $Len = StringLen($String), $NewString = ''
    For $i = 0 To Round($Len / $n, 0) Step 1
    $NewString &= "'" & StringLeft($String, $n) & "' & _" & @CRLF
    $String = StringTrimLeft($String, $n)
    Next
    Return StringTrimRight($NewString, 5) & @CRLF ; Das Letzte Mal braucht man keinen Anhang. Der Zeilenumbruch ist, falls man mehrere Dateien hat.
    EndFunc ;==>_Trennung

    [/autoit] [autoit][/autoit] [autoit]

    #Region - Interne Benutzung
    Func _LZ77_4096_16_Comp($String)
    $String = StringReplace($String, Chr(0), '[N]', 0, 1)
    Local $WortBuchGroesse = 4096, $LexikonZeichen = StringLen($String)
    If $LexikonZeichen > $WortBuchGroesse Then $LexikonZeichen = $WortBuchGroesse
    Local $SuchFensterZeichen = 16, $Lexikon = _Nullen($LexikonZeichen), $SuchFenster = '', $len = StringLen($String), $OptimierterString = '', $Suchlaenge = $SuchFensterZeichen, $StrInStr = 0
    $SuchFenster = StringLeft($String, $SuchFensterZeichen)
    $String = StringTrimLeft($String, $SuchFensterZeichen)
    For $i = 1 To $len Step 1
    If $SuchFenster = '' Then ExitLoop
    For $o = $SuchFensterZeichen To 1 Step -1
    $Suchlaenge = $o
    $StrInStr = StringInStr($Lexikon, StringLeft($SuchFenster, $Suchlaenge), 1, -1)
    If $StrInStr Then
    $Suchlaenge = StringLen(StringLeft($SuchFenster, $Suchlaenge))
    ExitLoop
    EndIf
    Next
    If $StrInStr Then
    $OptimierterString &= Hex($StrInStr - 1, 3) & Hex($Suchlaenge - 1, 1)
    $Lexikon &= StringMid($Lexikon, $StrInStr, $Suchlaenge)
    $Lexikon = StringTrimLeft($Lexikon, $Suchlaenge)
    $SuchFenster = StringTrimLeft($SuchFenster, $Suchlaenge)
    $SuchFenster &= StringLeft($String, $Suchlaenge)
    $String = StringTrimLeft($String, $Suchlaenge)
    $OptimierterString &= Hex(Asc(StringLeft($SuchFenster, 1)), 2)
    $Lexikon &= StringLeft($SuchFenster, 1)
    $Lexikon = StringTrimLeft($Lexikon, 1)
    $SuchFenster = StringTrimLeft($SuchFenster, 1)
    $SuchFenster &= StringLeft($String, 1)
    $String = StringTrimLeft($String, 1)
    Else
    $OptimierterString &= '0000' & Hex(Asc(StringLeft($SuchFenster, 1)), 2)
    $Lexikon &= StringLeft($SuchFenster, 1)
    $Lexikon = StringTrimLeft($Lexikon, 1)
    $SuchFenster = StringTrimLeft($SuchFenster, 1)
    $SuchFenster &= StringLeft($String, 1)
    $String = StringTrimLeft($String, 1)
    EndIf
    Next
    Return Hex($LexikonZeichen - 1, 3) & Hex($SuchFensterZeichen - 1, 1) & $OptimierterString
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func _Nullen($a) ; Damit das Lexikon voller Nullen ist.
    Local $n = ''
    For $i = 1 To $a Step 1
    $n &= '0'
    Next
    Return $n
    EndFunc ;==>_Nullen

    [/autoit] [autoit][/autoit] [autoit]

    Func _ZeichenArray()
    Local $sZ = '!"#%&,-/:;=@GHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖרÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ', $UBound = StringLen($sZ), $b[$UBound]
    For $i = 0 To $UBound - 1 Step 1
    $b[$i] = StringLeft($sZ, 1)
    $sZ = StringTrimLeft($sZ, 1)
    Next
    Return $b
    EndFunc ;==>_ZeichenArray

    [/autoit] [autoit][/autoit] [autoit]

    Func _Ersetzung_Comp($a)
    Local $l_alt = StringLen($a), $l_neu = 0, $st, $er, $n = 0, $_____Zeichen = _ZeichenArray(), $_____Zeichenmenge = UBound($_____Zeichen), $t = TimerInit()
    While 1
    $st = _Analyse($a) ; $st = Meist vorkommender String
    $a = StringReplace($a, $st, $_____Zeichen[$n], 0, 1)
    $a &= $st ; Und rechts an $a angehängt. $a = Urspringsstring
    $l_neu = StringLen($a) ; Neue Stringlänge
    $n += 1 ; Durchläufe
    If ($n = $_____Zeichenmenge Or $l_neu >= $l_alt) Then ;Nur Abbrechen, wenn tatsächlich nix geht. (nicht wenn der 8er nicht klappt...)
    ExitLoop
    EndIf
    $l_alt = $l_neu
    If TimerDiff($t) > 500 Then
    GUICtrlSetData($hLabel, 'Komprimiere... ' & Round($n / $_____Zeichenmenge * 100, 0) & ' %')
    $t = TimerInit()
    EndIf
    WEnd
    Return $a & Hex($n, 2) ; Rückgabe ist der Komprimierte String und die Anzahl ersetzungen
    EndFunc ;==>_Ersetzung_Comp

    [/autoit] [autoit][/autoit] [autoit]

    Func _Analyse($sData, $l = 2)
    Local $StringLaenge = StringLen($sData), $Top[2], $StringPart, $Replacements, $BenutzteStrings[256][256]
    For $i = 0 To $StringLaenge - ($l - 1) Step 1
    $StringPart = StringMid($sData, $i, $l)
    If Not $BenutzteStrings[Asc(StringLeft($StringPart, 1))][Asc(StringRight($StringPart, 1))]Then ; Damit keine Strings doppelt getestet werden...
    $BenutzteStrings[Asc(StringLeft($StringPart, 1))][Asc(StringRight($StringPart, 1))] = True
    StringReplace($sData, $StringPart, $StringPart, 0, 1)
    $Replacements = @extended
    If $Replacements >= $Top[0] Then
    $Top[0] = $Replacements
    $Top[1] = $StringPart
    EndIf
    EndIf
    Next
    Return $Top[1]
    EndFunc ;==>_Analyse

    [/autoit] [autoit][/autoit] [autoit]

    #EndRegion - Interne Benutzung

    [/autoit]

    Edit: Das Funktioniert immer. Obs kompilliert ist oder nicht ist wurscht !

    lg
    Mars(i)

    Dateien

    BildAusRessource.rar 92,48 kB – 433 Downloads
  • AutoIt + 3D = ?

    • Mars
    • 9. August 2011 um 22:12

    Kleines Update was das MarioFeeling angeht.

    Wie man sehen kann ist es wohl doch möglich mehr Steine als ich zuerst erwartet habe einzubauen ohne die Auslastung ins unendliche zu treiben.
    Es sind jetzt über 30 (bisher nur vorne) Animierte 3D Stiene vorhanden und ein Mario mit dem darin herumgehüpft werden kann.

    Ansich ist alles komplett in 2D. (Die Steine haben "echtes 3D", was man aber noch nicht wirklich sieht, weil sie jetzt unbewegt sind und seitlich keine Texturen haben.)

    Nächstes Projekt ist also Mario 3D...
    (zum glück gibts schon eine sehr gute Mario Implementierung wo ich einiges abgucken kann :P)

    lg
    Mars(i)

  • AutoIt + 3D = ?

    • Mars
    • 9. August 2011 um 15:36

    Die Spielfigur ist bisher auch nur ein Rechteck.
    Und die Kollisionserkennung ist extrem Primitiv gehalten.

    Sollte alles meinen Wünschen entsprechend klappen sollte einem Mario in (pseudo) 3D Grafik nichts im Wege stehen. (Das wird aber noch daaaauern. :P. Hab noch andere Projekte^^)
    (Pseudo, weil keine Kameraführung möglich sein wird. Die Kamera ist fest in der mitte des Bildes.)

    Wollte nur mal zeigen, was in AutoIt ohne große Kunstgriffe möglich ist :P

    UEZ: :/^^ Ohne Asm wird es hart die Seiten zu Zeichnen (die sind bisher ja noch einfarbig) und eine Kantenglättung drüberrauschen zu lassen. (dann sind die Blauen Ränder weg). Ansonsten wird vorerst erstmal alles komplett in AutoIt bleiben. Den Würfel hab ich bei dir ein bisschen abgeguckt. Der von mir gebaute hatte etwa den dreifachen Rechenbedarf für das gleiche Ergebnis. Da hab ich einige Elemente aus deinem übernommen...

    Noch ist garkein Asm verwendet worden. (es ist nur im Archiv, weil die Imageudf sonst Probleme macht. Da wird für manches Asm genutzt...)

    lg
    Mars(i)

  • AutoIt + 3D = ?

    • Mars
    • 9. August 2011 um 15:18

    Moin,

    ein kleiner Test...
    Mario 3D.... Ich bin unterwegs !

    Edit:
    1ster Schritt ist getan. Es sieht jetzt schonmal etwa so aus, wie Mario :P

    lg
    Mars(i)

    Dateien

    Desktop.rar 509,39 kB – 366 Downloads Desktop_Neu.rar 518,04 kB – 258 Downloads
  • [Beendet] Wegfindungs-Scriptwettbewerb

    • Mars
    • 8. August 2011 um 20:52

    Ich glaube nicht^^

    Mein Skript war eigentlich mehr oder Weniger ein Test, ob man das ziel auch durch Zufall finden kann.
    Der Spieler läuft zufällig eine Zufällige Strecke. Mit einer Wahrscheinlichkeit ungleich 0 erreicht er so irgendwann das Ziel, sollte es erreichbar sein.

    Die Methode um das Ziel schneller zu erreichen ist gleichzeitig der Untergang, falls der Weg zu weit versperrt ist.
    Es werden Richtungen gestrichen die weiter vom Ziel weg führen, es sei denn alle Anderen Wege sind blockiert.
    Dadurch kann das Ziel mit fast optimalem Weg in relativ kurzer Zeit gefunden werden wenn es frei zugänglich ist.
    Sollte der Weg versperrt sein wird das skript aber endlos laufen und keine Lösung finden. Deshalb der Timer auf 20sek^^

    lg
    Mars(i)

  • [Anfänger] Tutorial: Wie Programmiere ich Snake ?

    • Mars
    • 8. August 2011 um 20:47

    hmm...

    also, dass es hackt kann ich nicht bestätigen.

    Es hat den Anschein, wenn man mit einer 4 Punkte langen Schlange schnell dreht, aber das liegt daran, dass sich alle Teile ein Mal bewegen und das Endergebnis identisch aussieht. Wenn man den Kopf anderst färbt tritt diese illusion nicht auf.

    lg
    Mars(i)

  • [Spiel] Snake

    • Mars
    • 3. August 2011 um 17:09

    Ich bin halt der Meister was png´s angeht :P
    Benutze doch einfach google um zu finden was du suchst.
    http://www.google.de/search?q=APNG&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:de:official&client=firefox-a

    lg
    Mars(i)

  • [Spiel] Snake

    • Mars
    • 3. August 2011 um 14:51

    Auf jeden brauch ich klicks !
    Ich bin aber sowieso dabei alle Spiele auf die HighscoreUDF zu setzen.
    DropOff und DropOff2 sind schon aktualisiert.

    lg
    Mars(i)

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™