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. AspirinJunkie

Beiträge von AspirinJunkie

  • Huffman-Kodierung + Helferfunktionen für Umgang mit binären Daten

    • AspirinJunkie
    • 26. Mai 2023 um 10:25
    Zitat von Andy

    Wieso Sonderfall? Die Anzahl der angehängten Nullbits entstehen doch immer, wenn die Summe der Anzahl der enkodierten Bits nicht glatt durch 8 teilbar ist. Und der Dekodierere "zufällig" beim angehängten Bitmuster ein Zeichen (Blatt des Huffman-Baums) erkennt.

    Na der Sonderfall ist der, dass ein Zeichen den Code 0 besitzt und genau dieses Zeichen am Ende des Strings auftaucht. Das meinte ich mit Sonderfall. Indem ich alle Nullen hinten wegschneide habe ich das bisher umgangen.

    Nun habe ich tatsächlich die Anzahl der ungenutzten Bits noch mit hinzugefügt (gerade bei github hochgeladen).
    Jetzt wird die Größe des kodierten Streams in 37,5 % aller Fälle um 1 Byte ansteigen.
    Ich denke das ist verschmerzbar denn nun hat man den Sonderfall auch noch mit abgedeckt.

    Zitat von Andy

    diese exzessive Beachtung sämtlicher(!) Design- und Coderegeln

    Ich denke da sollte kein professioneller Programmier drüber schauen - dann würde die Aussage wohl ziemlich schnell zerpflückt werden.

  • Huffman-Kodierung + Helferfunktionen für Umgang mit binären Daten

    • AspirinJunkie
    • 25. Mai 2023 um 21:08
    Zitat von Andy

    In der Funktion _huff_decodeBinaryToString() versuchst du ganz zum Schluß per RegExReplace() etwas, was imho so nicht funktionieren kann...außer bei "Textdateien" aka Dateien ohne Nullbytes.

    Doch doch. Das funktioniert schon für den Fall, für den es gedacht war.
    Nämlich folgender:

    AutoIt
    #include "Huffman.au3"
    
    $sString = "AABC"
    
    Global $bEncoded = _huff_encodeString($sString)
    Global $sStringDecoded = _huff_decodeBinary($bEncoded)
    
    ConsoleWrite($sStringDecoded & @CRLF)

    Führe das einmal mit dem StringRegExpReplace() aus und einmal ohne und du siehst welcher Fall damit gelöst werden soll.

    Beide Varianten scheitern jedoch weiterhin an diesem String: "ABCC"

    Die Lösung ist tatsächlich so wie du sagst: Man muss die Anzahl der aufgefüllten Nullbits mitspeichern.
    Das könnte man gleich am Anfang der kodierten Daten in 3 Bits packen (kann ja nur maximal den Wert 7 annehmen).
    Das war mir durchaus bewusst - ich war in dem Moment aber schlicht zu faul für diesen arg unwahrscheinlichen Sonderfall noch diese Anpassung mit reinzudängeln.

    Ich finde es aber echt geil wie ihr beiden tatsächlich diesen Code bis ins kleinste Detail verstanden habt.
    Ich selbst hatte ab und an schon Probleme zu verstehen was ich eigentlich gemacht habe aber in eurem Fall ist das gleich nochmal ein Zacken schärfer. :thumbup:

  • Huffman-Kodierung + Helferfunktionen für Umgang mit binären Daten

    • AspirinJunkie
    • 24. Mai 2023 um 09:02

    Ha! Sehr gut!
    Ich wusste doch, dass es sich lohnt das Ding zu veröffentlichen.
    Ich hatte damit gerechnet, dass effiziente Methoden zum effektiven preprocessing des Strings gepostet werden.
    Aber, dass an der Huffmantabelle noch weiter geschraubt werden kann, hatte ich nicht auf dem Schirm, da ich tatsächlich davon ausgegangen bin, dass die bei meinem Ansatz schon äußerst platzsparend ist.

    Tja und dann kommt ihr und haut Methoden raus um das Char-Array noch weiter einzudampfen.

    Allerdings müsst ihr mir noch nachhelfen, da ihr aktuell vom Methodenverständnis her noch einige Kilometer weit vor mir lauft.

    Ich versuche den Ansatz mal mit meinen Worten zusammenzufassen und ihr sagt ob ich es gerafft habe oder eben nicht:

    • Man nehme das originale Char-Array und sortiere es.
    • Die Berechnungsvorschrift um vom sortierten Array zum ursprünglichen Array zu kommen, kann als Abfolge von swaps beschrieben werden.
    • Je nach Umfang der Umsortierung ist dies mal eine kurze, mal eine lange Liste. Sie ist aber immer kürzer (geht auch gleich lang?) als das Gesamtarray.
    • Problem hierbei: Die Berechnungsvorschrift zwischen 2 Permutationen lässt sich 1. nicht mit einem allgemeingültigem Algorithmus finden und 2. nicht immer effektiv. (meine Recherche erbrachte, dass man diese Swapliste mit dem Pancake-Sorting-Algorithmus erhalten kann)
    • Diese Liste ist nun der erste Teil.
    • Dazu braucht es nun die Werte des Arrays. Diese werden folgendermaßen kodiert:
      • Nehme den kleinsten Wert als Ausgang.
      • Von diesem ausgehend speichere die relative Wertdifferenz zwischen den aufeinanderfolgenden Werten (Abstandskodierung)
      • Da die Abstände große Peaks enthalten, kann diese Liste gut per Huffman kodiert werden.
    • Man hat nun also die Swap-Liste + die Huffman-kodierte Char-Abstandsliste und beide zusammen können im Idealfall kleiner sein als das unkodierte Char-Array.

    Soweit verstanden?
    Die Abstandskodierung fand ich erst einmal sehr erhellend und dann fiel mir irgendwann auf, dass ich das ähnliche Prinzip bereits in der BinaryHelpers.au3 in der Funktion _bin_shrinkString2Bin() umgesetzt habe (dort sind es jedoch keine Abstände sondern Absolutlevel - von daher nur halb soweit gedacht).

  • Huffman-Kodierung + Helferfunktionen für Umgang mit binären Daten

    • AspirinJunkie
    • 23. Mai 2023 um 06:41
    Zitat von Mars

    Du wusstest doch, dass ich hier jetzt irgendetwas poste :P

    Hehe - du warst der eigentliche Grund warum ich meinen Huffman-Ansatz von damals nochmal hübsch in UDF-Form restauriert habe.
    Sonst wird sich kaum einer hierfür interessieren.

    Zitat von Mars

    -> Man kann eine Permutation finden, sodass die Chars alle sortiert sind.
    -> Die Charliste besteht also aus [Permutation] + [SortierteCharliste], beides lässt sich ziemlich gut (dicht am Entropielimit) komprimieren.
    -> Die Permutation hat schöne Eigenschaften (z.B. nichts doppelt, in sortierter Form sind es die Zahlen 0 bis n-1, also ist im sortierten Zustand der Abstand zweier Werte immer 1, und so weiter), die sortierte Charliste hat quasi überall den Abstand 1 (den man via "Huffman im Huffman" entropiekodieren kann).

    Ich habe noch (viele) Verständnisprobleme hierbei.
    Vielleicht mal mein bisheriges Verständnis + Fragen hierzu:

    • Bei der kanonischen Huffman-Kodierung hat man die Codes schön kompakt gespeichert.
      Die zugehörigen Zeichen sind aber weiter so wie sie sind einfach nur hintereinander geschrieben - ein String.
    • Diesen String kannst du nun ebenso weiter komprimieren?
    • Hierfür werden die Zeichen in eine andere Reihenfolge (Permutation) gebracht.
      Wie komme ich aber auf diese genaue Permutation oder gehen auch andere?
    • Nach was ist diese sortiert? So wie ich das erst einmal sehe, enthält die Permutation die Indizes der ursprünglichen Elemente in einer sortierten Menge - oder?
    • Wie diese dann zusammen komprimiert werden - da steck ich noch nicht drin.

    Kann man diesen Ansatz irgendwo nachlesen?
    Hat er einen Namen?

    Ansonsten bin ich mehr als schwer beeindruckt, dass du in dieser ganz kurzen Zeit meinen Code nicht nur offensichtlich verstanden hast, sondern ihn auch noch an den komplizierten Stellen signifikant erweitern/verbessern konntest.

  • Huffman-Kodierung + Helferfunktionen für Umgang mit binären Daten

    • AspirinJunkie
    • 22. Mai 2023 um 12:43

    Mit dieser UDF kann man einen String per Huffman-Kodierung kodieren bzw. komprimieren.
    Die Huffmantabelle wird hierbei ebenso Bestandtteil des kodierten Binaries, weswegen die kanonische Form der Huffmantabelle verwendet wird um den Overhead hierfür möglichst klein zu halten.

    Die UDF macht regen Gebrauch der integrierten UDF "BinaryHelpers.au3", welche Funktionen zum leichteren Umgang mit binären Daten in AutoIt enthält.
    Diese wurde bislang noch nicht gesondert von mir veröffentlicht und könnte für manchen auch alleine interessant sein.

    Wie verwendet man die UDF?

    folgendes Beispiel:

    AutoIt
    #include "Huffman.au3"
    
    ; lese den Quellcode der Seite autoitscript.com
    Global $sString = BinaryToString(InetRead("https://autoitscript.com"))
    ConsoleWrite("Original Size: " & BinaryLen(StringToBinary($sString)) & " Bytes" & @CRLF)
    
    ; kodiere den String per Huffman-Kodierung
    Global $bEncoded = _huff_encodeString($sString)
    ConsoleWrite("Encoded Size:  " & BinaryLen($bEncoded) & " Bytes" & @CRLF & _
        "Compress ratio: " & Round((1 - (BinaryLen($bEncoded) / BinaryLen(StringToBinary($sString)))) * 100.0, 1) & ' %' & @CRLF)
    
    ; dekodiere den String wieder aus dem Binary
    Global $sStringDecoded = _huff_decodeBinary($bEncoded)
    
    ; Prüfe ob der Originalstring und der dekodierte String gleich sind
    ConsoleWrite("$sString == $sStringDecoded: " & ($sString == $sStringDecoded) & @CRLF)
    Alles anzeigen

    erbringt folgende Ergebnisse:

    Code
    Original Size: 157081 Bytes
    Encoded Size:  102833 Bytes
    Compress ratio: 34.5 %
    $sString == $sStringDecoded: True

    Wie kann man die Komprimierungsrate noch weiter steigern?

    Die Huffmankodierung ist nur ein von mehreren möglichen Beispiel zur Komprimierung von Daten und kann mit diesen auch kombiniert werden.
    Wenn man z.B. den String erst auf Textebene vorkomprimiert (z.B. durch Wortwiederholungskomprimierung) und erst anschließend die Huffmankodierung darüber gießt, kann man sich seinen eigenen kleinen Komprimierer komplett in AutoIt schreiben.

    Das obere Beispiel habe ich mal um eine solche (simple!) Vorkomprimierung ergänzt:

    AutoIt
    #include "Huffman.au3"
    
    ; read out the autoitscript.com page as example string
    Global $sString = BinaryToString(InetRead("https://autoitscript.com"))
    ConsoleWrite("Original Size: " & BinaryLen(StringToBinary($sString)) & " Bytes" & @CRLF)
    
    ; precompress at text level by word repetition:
    Global $sStringCompressed = _strcmp_compressByWordRepetition($sString)
    
    ; encode the string with a canonical huffman encoding
    Global $bEncoded = _huff_encodeString($sStringCompressed)
    ConsoleWrite("Encoded Size:  " & BinaryLen($bEncoded) & " Bytes" & @CRLF & _
        "Compress ratio: " & Round((1 - (BinaryLen($bEncoded) / BinaryLen(StringToBinary($sString)))) * 100.0, 1) & ' %' & @CRLF)
    
    ; decode the string out of the binary
    Global $sStringDecoded = _huff_decodeBinary($bEncoded)
    
    ; decompress at text level
    $sStringDecoded = _strcmp_decompressByWordRepetition($sStringDecoded)
    
    ; check if original and decoded string are the same
    ConsoleWrite("$sString == $sStringDecoded: " & ($sString == $sStringDecoded) & @CRLF)
    
    
    
    
    
    
    
    ; Tokenbasierte Kompression - ersetzt wiederholende Teile durch Nummern im Text
    Func _strcmp_compressByWordRepetition($sString)
        Local   $mTmp[3], $aTmp[2], $mPos, $iLen, _
                $mWords[], _
                $iPos = 1, _
                $sWord, $iWord = 0
    
        ; Bereits vorhandene Präfixnummern escapen:
        $sString = StringRegExpReplace($sString, '(?s)\b(\d+)', Chr(27) & "$1")
    
        ; Einzelne Wörter aus dem String extrahieren
        Do
            $aMatch = StringRegExp($sString, '(?s)\G.*?(\b[a-zA-ZäöüßÄÖÜ][\wäöüßÄÖÜ]{2,}\b)', 1, $iPos)
            IF @error Then ExitLoop
            $iPos = @extended
            $sWord = $aMatch[0]
    
            If MapExists($mWords, $sWord) Then
                $aTmp = $mWords[$sWord]
                $mTmp = $aTmp[1]
                MapAppend($mTmp, $iPos - StringLen($sWord))
                $aTmp[1] = $mTmp
            Else
                Local $mTmp[]
                Local $aTmp[2] = [$iWord, $mTmp]
            EndIf
            $mWords[$sWord] = $aTmp
    
            $iWord += 1
        Until 0
    
        ; bereite die notwendigen Replaces auf
        Local $aReplaces[$iWord][3], $iIndRepl = 0
        For $sWord In MapKeys($mWords)
            $iLen = StringLen($sWord)
            $aTmp = $mWords[$sWord]
            $iWord = $aTmp[0]
            $mPos = $aTmp[1]
    
            If Ubound($mPos) < 1 Then ContinueLoop
            If $iLen <= Stringlen($iWord) Then ContinueLoop
    
            For $i In MapKeys($mPos)
                $iPos = $mPos[$i]
    
                $aReplaces[$iIndRepl][0] = $iPos
                $aReplaces[$iIndRepl][1] = $iLen
                $aReplaces[$iIndRepl][2] = $iWord
    
                $iIndRepl += 1
    
            Next
        Next
        Redim $aReplaces[$iIndRepl][3]
        _ArraySort($aReplaces)
    
        ; Wörter durch Nummern im Text selbst ersetzen
        For $i = UBound($aReplaces) - 1 To 0 Step -1
            $sString =  StringLeft($sString, $aReplaces[$i][0] - 1) & _
                        $aReplaces[$i][2] & _
                        StringTrimLeft($sString, $aReplaces[$i][0] + $aReplaces[$i][1] -1)
        Next
    
        Return $sString
    EndFunc
    
    
    ; Tokenbasierte Dekompression - stellt einen mit _strcmp_compressByWordRepetition() komprimierten String wieder her
    Func _strcmp_decompressByWordRepetition($sString)
        Local   $aTmp[3], _
                $mWords[]
                $iPos = 1
    
        ; Einzelne Wörter aus dem String extrahieren
        Do
            $aMatch = StringRegExp($sString, '(?s)\G.*?(\b[a-zA-ZäöüßÄÖÜ][\wäöüßÄÖÜ]{2,}\b|\b(?<!\x1B)\d+\b)', 1, $iPos)
            IF @error Then ExitLoop
            $iPos = @extended
    
            $aTmp[0] = $aMatch[0]
            $aTmp[1] = $iPos - StringLen($aMatch[0])
            $aTmp[2] = StringLen($aMatch[0])
            MapAppend($mWords, $aTmp)
        Until 0
    
        Local $aWords = _map_IntMap2Array($mWords)
        $aWords = _ArrayAinATo2d($aWords)
    
        ; Nummern wieder durch Buchstaben ersetzen
        Local $iWord
        For $i = UBound($aWords) - 1  To 0 Step -1
            If Not StringRegExp($aWords[$i][0], "^\d+$", 0) Then ContinueLoop
    
            $iWord = Int($aWords[$i][0])
            If $iWord >= UBound($aWords) Then ContinueLoop
            ;~ ConsoleWrite($iWord & @CRLF)
            $sString =  StringLeft($sString, $aWords[$i][1] - 1) & _
                        $aWords[$iWord][0] & _
                        StringTrimLeft($sString, $aWords[$i][1] + $aWords[$i][2] -1)
        Next
    
        ; Escapte Zahlen wieder unescapen:
        $sString = StringRegExpReplace($sString, '(?s)\x1B(\d+)', "$1")
    
        Return $sString
    EndFunc
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _map_IntMap2Array()
    ; Description ...: returns the values of a map only (useful for array-list like maps produced by MapAppend())
    ; Syntax ........: _map_IntMap2Array(ByRef $aMap)
    ; Parameters ....: ByRef $aMap - a map variable
    ; Return values .: 1D-array containing the values
    ; Author ........: aspirinjunkie
    ; Modified ......: 2022-07-13
    ; =================================================================================================
    Func _map_IntMap2Array(ByRef $aMap)
        Local $aRet[UBound($aMap)]
        Local $iInd = 0
        For $vEl In $aMap
            $aRet[$iInd] = $vEl
            $iInd += 1
        Next
        Return $aRet
    EndFunc   ;==>_map_IntMap2Array
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ArrayAinATo2d()
    ; Description ...: Convert a Arrays in Array into a 2D array
    ; Syntax ........: _ArrayAinATo2d(ByRef $A)
    ; Parameters ....: $A             - the arrays in array which should be converted
    ; Return values .: Success: a 2D Array build from the input array
    ;                  Failure: Null
    ;                     @error = 1: $A is'nt an 1D array
    ;                            = 2: $A is empty
    ;                            = 3: first element isn't a array
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _ArrayAinATo2d(ByRef $A)
        If UBound($A, 0) <> 1 Then Return SetError(1, UBound($A, 0), Null)
        Local $N = UBound($A)
        If $N < 1 Then Return SetError(2, $N, Null)
        Local $u = UBound($A[0])
        If $u < 1 Then Return SetError(3, $u, Null)
    
        Local $a_Ret[$N][$u]
    
        For $i = 0 To $N - 1
            Local $t = $A[$i]
            If UBound($t) > $u Then ReDim $a_Ret[$N][UBound($t)]
            For $j = 0 To UBound($t) - 1
                $a_Ret[$i][$j] = $t[$j]
            Next
        Next
        Return SetExtended($N, $a_Ret)
    EndFunc   ;==>_ArrayAinATo2d
    Alles anzeigen

    und hiermit erhalten wir nun folgende Ergebnisse:

    Code
    Original Size: 157081 Bytes
    Encoded Size:  73333 Bytes
    Compress ratio: 53.3 %
    $sString == $sStringDecoded: True

    >>Download und Quellcode auf GitHub<<

  • Andere au3-Dateien dem Script hinzufügen

    • AspirinJunkie
    • 16. Mai 2023 um 09:50

    Der Punkt ist allgemein eine relative Pfadangabe in Windows und nicht rein AutoIt-spezifisch.
    . bedeutet: das aktuelle Arbeitsverzeichnis.

    .. bedeutet: Eine Ordnerebene höher (kann mehrfach verwendet werden um noch weiter höher zu kommen).

    in deinem Beispiel bräuchtest du den Punkt also gar nicht sondern könntest einfach nur #include "Include\Avg.au3" schreiben.

  • Andere au3-Dateien dem Script hinzufügen

    • AspirinJunkie
    • 16. Mai 2023 um 06:23

    Ich glaube das ist etwa missverständlich geschrieben in der Hilfe.

    Die "..." sollen dort nicht wirklich eingetragen werden sondern sie stehen als Platzhalter für die Pfadangabe.


    Allerdings: So wie Moombas es im letzten Post geschrieben hat, sollte es funktionieren, wenn die Ordnerstruktur so ist wie beschrieben.
    Sprich:

    • Ordner Dart_App:
      • Hauptdatei: Main.au3
      • Ordner Include:
        • Datei Avg.au3

    Wenn dem so ist, dann lässt sich die Datei Avg.au3 innerhalb der Datei Main.au3 über verschiedenste Pfadangaben einbinden:

    AutoIt
    #include "Include\Avg.au3"
    #include "\Include\Avg.au3"
    #include ".\Include\Avg.au3"
    #include "..\Dart_App\Include\Avg.au3"
    #include "Include/Avg.au3"
    #include "/Include/Avg.au3"
    #include "./Include/Avg.au3"
    #include "../Dart_App/Include/Avg.au3"
    #include "./././../Dart_App/./././../Dart_App/./././../Dart_App/././././././Include/Avg.au3"


    Wie gesagt: All diese Varianten funktionieren nur, wenn die Ordnerstruktur tatsächlich wie oben beschrieben ist.
    Daran habe ich jedoch Zweifel, da dein letzter Versuch eigentlich hätte funktionieren müssen.

    Hinweis: Es würde auch ein Include in <> gehen anstatt in "". Das macht aber nicht viel Sinn, da man damit nur die Suchreihenfolge ändert. Bei <> sucht er erst im AutoIt integrierten Include-Ordner nach der Datei, dann optional in einem in der Registry eintragbaren zusätzlichen Pfad und als letztes im Skriptverzeichnis. Bei "" ist die Suchreihenfolge hingegen genau andersherum. Es bietet sich also an, <> zu verwenden, wenn man AutoIt-integrierte UDFs wie z.B. die Array.au3 einbinden will und "" zu verwenden, wenn man eigene Include-Dateien einbinden möchte.

  • Arrayreihenfolge

    • AspirinJunkie
    • 13. Mai 2023 um 22:33

    Na gut - ich denke ein viertes mal brauch ich auch nicht mehr zu nachzuhaken.

    Viel Erfolg Dir bei der Lösung deines eigentlichen Problems.

  • Arrayreihenfolge

    • AspirinJunkie
    • 13. Mai 2023 um 22:14
    Zitat von Alina

    Wofür brauche ich das?

    Ich möchte die Werte, die ich nur so voirliegen habe wie im Array $Array1_werte, in einer anderen Reihenfolge haben.

    Du sitzt also Samstag-Abends da und überlegst dir: Hm ich würde gerne mal mein Array in einer anderen Reihenfolge sortieren, dabei die Reihenfolge aus einem anderen Array mit den Indizes übernehmen und obendrein auch noch einen wechselnden Startwert vorgeben.

    Das ist doch nicht dein Anwendungsfall - das ist dein Ansatz für die Lösung eines bestimmten Problems.
    Nur dieses eigentliche Problem kennen wir bislang nicht - nur du.
    Es geht nicht darum, DASS du ein Array entsprechend sortieren möchtest sondern es geht um die Frage WARUM du ein Array entsprechend sortieren möchtest.

  • Arrayreihenfolge

    • AspirinJunkie
    • 13. Mai 2023 um 21:40
    Zitat von Alina

    Habe ich es nun verständlich erklärt?

    Meine Frage nach dem wofür und wieso wurde bislang noch nicht geklärt.
    Wie gesagt: Evtl. gibt es bereits schon einen völlig anderen Ansatz um dein eigentliches Problem zu lösen.

    Kann mir anhand des Geschriebenen eine Möglichkeit vorstellen:

    AutoIt
    #include <Array.au3>
    
    Global $Array1_werte = ["DK45","DK28","963","NOR17","731","575","276","679","366","NOR15","NOR58","NOR23","958","166","909","478","634","846","744","525","701","77","162","211","51DK","873","401","909","717","52","552","707","327","782","705","644","47","524","596","NOR88","246","700","197","696","497","913","35","99","DK42","725","652","584","701","36","296","402","483","961","NOR87","9","482","944","613","161","205","657","734","329","791","750","731","196","437","312","979","489","NOR55","787","39","FIN01","764","344","745","666","733","37","273","38","784","797","109","903","340","272","742","426","127","206","623","842","DK45","DK28","963","NOR17","731","575","276","679","366","NOR15","NOR58","NOR23","958","166","909","478","634","846","744","525","701","77","162","211","51DK","873","401","909","717","52","552","707","327","782","705","644","47","524","596","NOR88","246","700","197","696","497","913","35","99","DK42","725","652","584","701","36","296","402","483","961","NOR87","9","482","944","613","161","205","657","734","329","791","750","731","196","437","312","979","489","NOR55","787","39","FIN01","764","344","745","666","733","37","273","38","784","797","109","903","340","272","742","426","127","206","623","842","39","954","99NOR","FIN2","388"]
    
    ; Reihenfolge 64 Werte
    Global $Array2 = [55, 30, 17, 42, 27, 36, 15, 38, 18, 43, 54, 29, 16, 39, 26, 35, 31, 56, 41, 20, 33, 28, 37, 14, 44, 19, 32, 53, 40, 13, 34, 25, 57, 2, 45, 8, 21, 64, 51, 12, 46, 5, 60, 1, 52, 9, 24, 63, 3, 58, 7, 48, 61, 22, 11, 50, 6, 47, 4, 59, 10, 49, 62, 23]
    
    Global $_startwert_der_Reihenfolge = 18
    
    ; Index des Startwertes im $Array2 ermitteln
    $iStart = _ArraySearch($Array2, $_startwert_der_Reihenfolge)
    
    ; Rotierte das Array2 so, dass der Startwert am Anfang steht
    _ArrayRotate($Array2, $iStart)
    
    ; kopiere das Array1
    $Array1_werte_Neu = $Array1_werte
    
    ; Werte an neue Position schreiben
    For $i = 0 To Ubound($Array2) - 1
        $Array1_werte_Neu[$Array2[$i] - 1] = $Array1_werte[$i]
    Next
    
    ; Ergebnis ausgeben
    _ArrayDisplay($Array1_werte_Neu, "Das umsortierte Array")
    
    
    
    
    Func _ArrayRotate(ByRef $aArray, $iShift)
        Local $iSize = UBound($aArray)
        $iShift = Mod($iShift, $iSize)
        For $i = 1 To $iShift
            Local $vTemp = $aArray[0]
            For $j = 0 To $iSize - 2
                $aArray[$j] = $aArray[$j + 1]
            Next
            $aArray[$iSize - 1] = $vTemp
        Next
    EndFunc
    Alles anzeigen


    Es ist jedoch die Frage von Kanashius offen, was mit den Elementen passieren soll, die nicht mit erfasst werden, da $Array2 eine andere Dimension hat als $Array1. Bleiben die leer oder erhalten die den alten Wert an dieser Position?

    Ebenso ist noch fraglich ob die Position von der du sprichst 0 oder 1-basiert ist.

    Aber am Ende sollten wir wieder schnell zur Eingangsfrage zurück: Wofür brauchst du das genau und warum denkst du, dass genau das der Ansatz ist um dein eigentliches Problem zu lösen?

  • Arrayreihenfolge

    • AspirinJunkie
    • 13. Mai 2023 um 20:24

    Irgendwie sind deine Aufgabenstellungen oftmals - nunja - ein bisschen bizarr.

    Vielleicht wäre es sinnvoll zu erklären warum und wofür du genau diesen Ansatz benötigst.

    Evtl. (ich sage sogar wahrscheinlich) findet sich dann ein anderer - besserer Ansatz.

    Quasi das klassische X-Y-Problem.

    Im konkreten Fall verstehe ich das Ding mit dem Startwert nämlich noch nicht wirklich.

    Im Prinzip müsste man ja erstmal nur ein zweites leeres Array für die Werte erstellen und dann dieses anhand der Indizes in Array2 entsprechend befüllen.

    Aber sicher hab ich das bisher noch falsch verstanden - wie gesagt insbesondere das mit dem Startwert kapiere ich noch nicht

  • Download der Avast-Free-Offline-Dateien klappt seit ein paar Tagen nicht mehr mit AutoIt ... ?

    • AspirinJunkie
    • 8. Mai 2023 um 09:38
    Zitat von kilo

    Ich habe den Einsatz von Curl nicht hinbekommen. Download der Version (Windows 32 Bit) kein Problem, aber wie wird das Programm

    installiert / eingebunden?

    Welche Windows-Version nutzt du denn?
    In neueren Versionen von Windows 10 ist curl bereits so enthalten - da musst du nix downloaden, das sollte ad-hoc funktionieren.

    Ansonsten lädtst du halt die zip-Datei aus dem Link herunter und dort findet sich im Unterordner bin die Datei curl.exe.
    Diese entweder mit in das Verzeichnis vom Skript schmeißen oder in einen Pfad, welcher in der Path-Umgebungsvariable steht sodass die exe von anderen Programmen gefunden werden kann.

    Ansonsten noch: Welche Version von Autoit verwendest du?

  • Download der Avast-Free-Offline-Dateien klappt seit ein paar Tagen nicht mehr mit AutoIt ... ?

    • AspirinJunkie
    • 6. Mai 2023 um 11:48

    Naja eigentlich ist wirkliche Problem noch nicht geklärt.
    Die curl-Variante ist ja nur ein Workaround bzw. ein Test ob es damit geht.
    Wirklich weiter bei der Frage warum es mit InetGet nicht klappt, bringt uns das jetzt nicht.

    Aber klar - man kann prinzipiell bei sowas auf curl umsteigen.
    Dann wäre es aber sinnvoll wenn man die Funktion noch so erweitert, dass während des Downloads die Fortschrittsdaten ausgewertet werden können.
    Ich hab das mal über eine Callback-Funktion gelöst, so kann der User selbst bestimmen wie und was er davon verwendet:

    AutoIt
    #include <WinAPIConv.au3>
    
    ProgressOn("avast-Download", "") ; für Fortschrittsanzeige in _myProgress()
    
    Global $sUrl = "https://bits.avcdn.net/productfamily_ANTIVIRUS/insttype_FREE/platform_WIN/installertype_FULL/build_RELEASE/cookie_mmm_ava_998_999_000_m"
    Global $sOutput = _curl_dl($sUrl, "avast.exe", 0 , _myProgress)
    
    ProgressOff()
    
    
    
    ; benutzerdefinierte Funktion, welche während des Downloads die Fortschrittsangaben weiterverarbeitet
    Func _myProgress($mData)
        ProgressSet($mData.percentTotal, _
            StringFormat("Bisher: %s\nNoch: %s", $mData.timeCurrent, $mData.timeLeft), _
            StringFormat("%s / %s (%s/s)", _WinAPI_StrFormatByteSize($mData.bytesDownload), _WinAPI_StrFormatByteSize($mData.bytesTotal), _WinAPI_StrFormatByteSize($mData.speedCurrent)) _
        )
    EndFunc
    
    
    
    ; #FUNCTION# ====================================================================================================================
    ; Name ..........: _curl_dl
    ; Description ...: downloads a file with curl
    ; Syntax ........: _curl_dl(Const $sUrl,  $sTarget[,  Const $iTimeOut = 0, [$cbProgress = Default, [$sAdditionalParams = "-L"]]])
    ; Parameters ....: $sUrl           - the URL of the file to download
    ;                  $sTarget        - the complete (with filename) destination path of the file
    ;                  $iTimeOut       - [optional] timeout to prevent endless running
    ;                  $cbProgress     - If a function variable is set, it acts as a callback function to process the values of the current download progress.
    ;                                    The function receives a map with the progress data as the only parameter.
    ;                  $sAdditionalParams - additional user defined cmdline parameters for curl
    ; Return values .: Success - Return the cmdline output of curl
    ;                  Failure - Return the error cmdline output of curl, set @extended to the exit-code of curl and set @error to:
    ;                        @error = 1 - timeout reached
    ;                              = 2 - error during running curl
    ; Author ........: AspirinJunkie
    ; Modified ......: 2023-05-06
    ; ===============================================================================================================================
    Func _curl_dl(Const $sUrl, $sTarget, Const $iTimeOut = 0, $cbProgress = Default, $sAdditionalParams = "-L")
        If StringInStr($sTarget, ' ', 1) Then $sTarget = '"' & $sTarget & '"'
    
        Local $sCmd = StringFormat("curl.exe " & $sAdditionalParams & " -o %s %s", $sTarget, $sUrl)
        Local $hPID = Run($sCmd, '', @SW_HIDE, 8);
    
        If IsKeyWord($cbProgress) = 1 Then
        ; no progress function
    
            If ProcessWaitClose($hPID, $iTimeOut) = 0 Then Return SetError(1, @extended, False)
            Local $sRetVal = @extended
    
            ; read out the console outputs
            Local $sOutput = StdoutRead($hPID)
    
            ; if errors occured
            If $sRetVal <> 0 Then Return SetError(2, $sRetVal, $sOutput)
    
            Return SetExtended($sRetVal, $sOutput)
    
        Else
        ; progress function
            Local $iPercent, $fBytes, $fBytesWhole, $sOutput, $sStdOutCurrent, $sLastLine, $aProgressInfos
    
            Do
                $sStdOutCurrent = StdoutRead($hPID)
                If @error Then ExitLoop
                If $sStdOutCurrent = "" Then ContinueLoop
    
                $sOutput &= $sStdOutCurrent
                $sLastLine = StringRegExp($sOutput, '\V*$', 3)[0]
    
                $aProgressInfos = StringRegExp($sLastLine, '(?i)^(\s\s\d|\s\d\d|\d{3}|\h\h0)\h(.{5})\h(.{4})\h(.{5})\h(.{4})\h(.{5})\h(.{6})\h(.{6})\h(.{8})\h(.{8})\h(.{8})\h(.{5})$', 3)
                If @error Then ContinueLoop
    
                Local $mProgress[] ; map holding the data for the progress callback function
                ; 0      , 1         , 2   , 3       , 4   , 5       , 6           , 7           , 8         , 9            , 10       , 11
                ; % total, total size, % dl, bytes dl, % ul, bytes ul, dl avg speed, ul avg speed, time total, time current , time left, curr speed (bytes/s over last 5s)
                $mProgress["percentTotal"]     = Int($aProgressInfos[0])
                $mProgress["bytesTotal"]       = _SizeStringToBytes($aProgressInfos[1])
                $mProgress["percentDownload"]  = Int($aProgressInfos[2])
                $mProgress["bytesDownload"]    = _SizeStringToBytes($aProgressInfos[3])
                $mProgress["percentUpload"]    = Int($aProgressInfos[4])
                $mProgress["bytesUpload"]      = _SizeStringToBytes($aProgressInfos[5])
                $mProgress["speedAvgDownload"] = _SizeStringToBytes($aProgressInfos[6])
                $mProgress["speedAvgUpload"]   = _SizeStringToBytes($aProgressInfos[7])
                $mProgress["timeTotal"]        = StringStripWS($aProgressInfos[8], 1)
                $mProgress["timeCurrent"]      = StringStripWS($aProgressInfos[9], 1)
                $mProgress["timeLeft"]         = StringStripWS($aProgressInfos[10], 1)
                $mProgress["speedCurrent"]     = _SizeStringToBytes($aProgressInfos[11])  ;(bytes/s over last 5s)
    
                Call(IsString($cbProgress) ? $cbProgress : FuncName($cbProgress), $mProgress)
                If @error Then ContinueLoop
            Until False
    
            Return $sOutput
        EndIf
    EndFunc
    
    
    ; #FUNCTION# ====================================================================================================================
    ; Name ..........: _SizeStringToBytes
    ; Description ...: convert a size string for bytes with prefixes (like from _WinAPI_StrFormatByteSize) to bytes only
    ; Syntax ........: _SizeStringToBytes($sSize[,  $bPow2 = True])
    ; Parameters ....: $sSize               - size string - e.g. 6.2M, 334K, 74MB, 1234k
    ;                  $bPow2               - [optional] if true: power of two (1 kB = 1024 Bytes), if false: power of ten (1 kB = 1000 Bytes)
    ; Return values .: bytes as number type
    ; Author ........: AspirinJunkie
    ; Modified ......: 2023-05-06
    ; ===============================================================================================================================
    Func _SizeStringToBytes($sSize, $bPow2 = True)
        Local $fNum = Number($sSize)
        If StringInStr($sSize, "K", 2, -1) Then Return $fNum * ($bPow2 ? 2^10 : 10^3)
        If StringInStr($sSize, "M", 2, -1) Then Return $fNum * ($bPow2 ? 2^20 : 10^6)
        If StringInStr($sSize, "G", 2, -1) Then Return $fNum * ($bPow2 ? 2^30 : 10^9)
        If StringInStr($sSize, "T", 2, -1) Then Return $fNum * ($bPow2 ? 2^40 : 10^12)
        If StringInStr($sSize, "P", 2, -1) Then Return $fNum * ($bPow2 ? 2^50 : 10^15)
        Return $fNum
    EndFunc
    Alles anzeigen
  • Download der Avast-Free-Offline-Dateien klappt seit ein paar Tagen nicht mehr mit AutoIt ... ?

    • AspirinJunkie
    • 5. Mai 2023 um 08:53

    Das klingt ja wirklich ziemlich merkwürdig.
    Anhand deiner Versuche versuche ich mal zusammenzufassen und auszuschließen:

    • andere Programme auf dem Rechner können downloaden --> es ist keine geblockte IP
    • Anderer Rechner + VM ohne Virenscanner --> BS-Config und Virenscanner ist es nicht
    • Bei allen anderen funktioniert das gleiche Skript --> kein Skriptproblem oder AutoIt-seitiges Problem


    Was ich als nächstes versuchen würde:

    • Bei Firefox in den Entwicklertools mal schauen, welchen User-Agent dieser beim Request mitsendet und diesen in AutoIt per HTTPSetUserAgent() auch setzen.
    • Den Download im Internet Explorer (nicht Edge!) probieren - Hintergrund: InetGet nutzt gemeinsame Libs mit dem IE.
    • Download per curl: Ist in Windows mittlerweile eingebaut (neueste Version gibt es >>hier<<). Wenn es funktioniert ließe sich der Download hierüber im Skript realisieren - Beispiel:
    AutoIt
    Global $sUrl = "https://bits.avcdn.net/productfamily_ANTIVIRUS/insttype_FREE/platform_WIN/installertype_FULL/build_RELEASE/cookie_mmm_ava_998_999_000_m"
    
    Global $sOutput = _curl_dl($sUrl, @ScriptDir & "\avast.exe")
    If @error Then ; Fehler während curl-Ausführung
        MsgBox(48, "Fehler (Exit-Code: " & @extended & ")", $sOutput)
    Else ; alles i.o.
        ConsoleWrite($sOutput & @CRLF)
    EndIf
    
    
    ; #FUNCTION# ====================================================================================================================
    ; Name ..........: _curl_dl
    ; Description ...: downloads a file with curl
    ; Syntax ........: _curl_dl(Const $sUrl,  $sTarget[,  Const $iTimeOut = 0])
    ; Parameters ....: Const sUrl           - the URL of the file to download
    ;                  $sTarget             - the complete (with filename) destination path of the file
    ;                  Const                - [optional] timeout to prevent endless running
    ; Return values .: Success - Return the cmdline output of curl
    ;                  Failure - Return the error cmdline output of curl, set @extended to the exit-code of curl and set @error to:
    ;                        @error = 1 - timeout reached
    ;                              = 2 - error during running curl
    ; Author ........: AspirinJunkie
    ; Modified ......: 2023-05-05
    ; ===============================================================================================================================
    Func _curl_dl(Const $sUrl, $sTarget, Const $iTimeOut = 0)
        If StringInStr($sTarget, ' ', 1) Then $sTarget = '"' & $sTarget & '"'
    
        Local $sCmd = StringFormat("curl.exe -L -o %s %s", $sTarget, $sUrl)
        Local $hPID = Run($sCmd, '', @SW_HIDE, 8);
    
        If ProcessWaitClose($hPID, $iTimeOut) = 0 Then Return SetError(1, @extended, False)
        Local $sRetVal = @extended
    
        ; read out the console outputs
        Local $sOutput = StdoutRead($hPID)
    
        ; if errors occured
        If $sRetVal <> 0 Then Return SetError(2, $sRetVal, $sOutput)
    
        Return SetExtended($sRetVal, $sOutput)
    EndFunc
    Alles anzeigen

    Edit: Tja da war ich mit meiner curl-Idee wohl einen Tick zu spät :S

  • Teil eines Arrays wie in Excel bearbeiten

    • AspirinJunkie
    • 15. April 2023 um 20:53

    Du verwendest eine ältere Version von AutoIt ohne Maps.

    installiere dir die aktuelle Version von AutoIt.

  • *.zip *.7z Archive durchsuchen ohne entpacken

    • AspirinJunkie
    • 13. April 2023 um 22:04

    Es liest nur die enthaltenen Dateien aus. Siehe Dokumentation zur 7za.exe

  • *.zip *.7z Archive durchsuchen ohne entpacken

    • AspirinJunkie
    • 13. April 2023 um 20:10

    Von 7-Zip gibt es eine Kommandozeilenversion, welche du super verwenden kannst um mit dieser per Skript zu arbeiten.
    Natürlich kann man mit dieser sich auch eine Dateiliste ausgeben lassen.

    Das kann man z.B. folgendermaßen machen - daraus ist auch schnell eine Funktion zur Wiederverwendung gebastelt:

    AutoIt
    #include <Array.au3>
    
    ; Pfad zur 7za.exe
    Global $sPath7Za = @ScriptDir & "\7za.exe"
    
    ; Pfad zur Zip/7z-Datei
    Global $sPathZipFile = "C:\Users\Admin\Downloads\7z2201-extra.7z"
    
    ; 7za Datei analysieren lassen
    Global $hPID = Run('"' & $sPath7Za & '" l "' & $sPathZipFile & '"', "", @SW_HIDE, 2)
    
    ; warten bis Prozess beendet ist
    ProcessWaitClose($hPID)
    
    ; Rückgabe in Variable einlesen:
    Global $sFileList = StdoutRead($hPID)
    
    ; Dateiliste auslesen:
    Global $aFilesRaw = StringRegExp($sFileList, '(?xm)^(20\d\d-\d\d-\d\d)\h(\d\d:\d\d:\d\d).{6}\h+(\d+)\h+(\d*)\h+(.+)$', 4)
    
    ; In 2D-Array konvertieren:
    Global $aFiles[UBound($aFilesRaw)][5]
    Global $iC = 0
    For $aFile In $aFilesRaw
        For $i = 0 To 4
            $aFiles[$iC][$i] = $aFile[$i+1]
        Next
        $iC += 1
    Next
    
    ; Dateiliste ausgeben:
    _ArrayDisplay($aFiles, "Dateiliste", "", 64, "|", "Datum|Zeit|Größe|komprimiert|Name")
    Alles anzeigen
  • TCP - Send

    • AspirinJunkie
    • 7. April 2023 um 09:14

    Nur zur Ergänzung (ohne eine Bewertung abzugeben): Es gibt noch eine andere Möglichkeit sich seine Strings mit variablen Inhalten zusammenzubauen: Opt("ExpandVarStrings", 1).
    Wenn man diese Option setzt, werden Variablen und Makros innerhalb von Stringdefinitionen ausgewertet.
    Auf die Art kann man evtl. seinen String etwas übersichtlicher zusammenbauen - Beispiel:

    AutoIt
    ; Aktiviert die Variablenauswertung in Stringdefinitionen
    $iOldOpt = Opt("ExpandVarStrings", 1)
    
    $sVersion = "1.2.3.4"
    $sMedium = "Wireless"
    $sKanal = "1234"
    
    $sText = '<?xml VERSION="1.0" ENCODING="UTF-8"?>@CRLF@' & _
             '<LISA>@CRLF@' & _
             '@TAB@<VERSION>$sVersion$</VERSION>@CRLF@' & _
             '@TAB@<MEDIUM>$sMedium$</MEDIUM>@CRLF@' & _
             '@TAB@<KANAL>$sKanal$</KANAL>@CRLF@' & _
             '@TAB@<SENDER>@IPAddress1@</SENDER>@CRLF@' & _
             '@TAB@<ENTSTEHUNG>@MDAY@.@MON@.@YEAR@ @HOUR@:@MIN@:@SEC@ Uhr</ENTSTEHUNG>@CRLF@' & _
             '</LISA>'
    
    ; Option wieder auf den vorherigen Wert setzen (falls nötig)
    Opt("ExpandVarStrings", $iOldOpt)
    
    ConsoleWrite($sText & @CRLF)
    Alles anzeigen
  • RegEx - mein Kampf

    • AspirinJunkie
    • 6. April 2023 um 11:57
    Zitat von GML

    Ich habe (als Array):
    [...]

    ca. 200 Einträge dzt.
    [...]

    Natürlich könnte ich für jeden Eintrag "192.168.10.99|NAS" die Schlüsselwörter in einer Schleife durchprüfen (StringInStr..), das dauert halt.

    Wieviele Schlüsselwörter sind es denn, dass bei lediglich 200 Einträgen das so lange dauert?
    Bzw. was heißt denn "lange dauert" hier konkret?

    So wie ich das verstehe (bitte korrigieren!):
    Du gehst das Array durch. Zu jedem Arrayeintrag existiert in einem GUI ein jeweiliger Button.
    Sollte ein bestimmtes Schlüsselwort auftauchen (z.B. "Router" oder "Switch" wäre Kategorie "Netzwerk"), dann wird der Button in der jeweiligen Farbe der Kategorie eingefärbt.
    Stimmt so?

    Dann stellt sich für mich die Frage in welcher Form die Schlüsselwörter stehen, wie du diese überprüfst (sicherlich mit StringInStr?) und warum ein RegEx da schneller sein sollte?

    Mach am besten mal ein minmales Beispiel dazu.

    Edit: Ok ich versuche mal mehr nachzuvollziehen was du bei dir machst.
    Aktuell machst du sicherlich soetwas in der Art?:

    AutoIt
    ; iteriere alle Arrayeinträge
    For $i = 0 To UBound($aArray) - 1
    
        ; prüfe ob Keyword vorkommt:
        For $sKeyword In $aKeyWords
            If StringInStr($aArray[$i][1], $sKeyword, 2) Then
                ; färbe Button
                ExitLoop
            EndIf
        Next
    Next
    Alles anzeigen

    Und die innere Schleife möchtest du nun durch ein StringRegExp ersetzen?
    Dann hast du es im Grunde oben schon ziemlich richtig hingeschrieben:

    AutoIt
    ; iteriere alle Arrayeinträge
    For $i = 0 To UBound($aArray) - 1
    
        ; prüfe ob Keyword vorkommt:
        If StringRegExp($aArray[$i][1], '(?i)DNS|Gateway|Server|NAS') Then
                ; färbe Button
        Next
    Next
  • Hängendes AutoIt Script

    • AspirinJunkie
    • 30. März 2023 um 08:43

    Dann braucht wirklich dein Skript.
    Der Idealfall wäre ein Minimalskript.
    Also ein möglichst kleines Skript was das beschriebene Verhalten reproduziert und alles andere was nichts mit dem Fehler zu tun hat entfernt hat (z.B. die GUI und derartiges könnte hier wahrscheinlich raus).

    Der Vorteil für dich: Bei der Erstellung eines solchen Minimalskriptes grenzt du selbst automatisch die Ursache schrittweise ein und die Wahrscheinlichkeit ist hoch bereits dabei die Fehlerquelle zu detektieren.

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™