Beiträge von Yjuq

Xenon

Ups ja, sollte eine addition sein. xd

Wie man auf die 3 Zahlen kommt weiß ich noch nicht, aber hier einmal die verkürzte Version von der oben genannten Aufgabenstellung:

Mein Ansatz ist dass ich einfach über einen Monat ein neuronales Netz trainiere um Texte zu komprimieren / dekomprimieren. Keine Ahnung ob es hinterher zu gebrauchen ist - aber was soll's. Das training wird natürlich unabhängig von AutoIt gemacht da ich sonst ja noch in 2 Jahren dran sitzen würde ;D

Testdaten lassen sich glücklicherweise auch sehr einfach generieren. Also hab ich's damit ziemlich einfach.

Zitat von SOLVE-SMART

Eine Optimierung würde jedoch in einem Folgeschritt folgen, daher nicht relevant für die Aufgabenstellung.

Falls du daran denkst ggf. bereits gefundene Zahlen zwischenzuspeichern um den Rechenaufwand zu minimieren -> Das klappt nicht. Es stellt sich heraus (zumindest was ich dazu versucht hatte) dass dies langsamer ist und zusätzlich Speicher im RAM benötigt. Zumindest mit den Lösungsansätzen welche ich versucht hatte. Es ist schneller die Zahlen einfach neu zu berechnen.

Hi, ich schreibe nicht mehr viel in AutoIt. Daher ist meine ursprüngliche Lösung in Lua. Ich habe jedoch den Code nach AutoIt übersetzt nachdem ich fertig war.

Lua 5.4 Skript: Alle "Happy Numbers" von 1 bis 10'000'000 in ca. 8 Sekunden in eine Text Datei.

AutoIt Skript: Alle "Happy Numbers" von 1 bis 100'000 in ca. 8 Sekunden in die Konsole.

Func isHappy($n)
    Local $r, $s, $x = $n

    While ($x <> 1) And ($x <> 4)
        $s = 0
        $n = $x

        While $n > 0
            $r = Mod($n, 10)
            $s += $r ^ 2
            $n = Floor($n / 10)
        WEnd

        $x = $s
    WEnd

    Return $x = 1
EndFunc

For $i = 1 To 100000
    If isHappy($i) Then
        ConsoleWrite($i & @CRLF)
    EndIf
Next

local function isHappy(n)
    local r, s
    local x = n

    while (x ~= 1) and (x ~= 4) do
        s = 0
        n = x
        
        while n > 0 do
            r = n % 10
            s = s + r * r
            n = n // 10
        end
        
        x = s
    end

    return x == 1
end

local file = io.open("happy_yjuq.txt", "w+")
for i = 1, 10000000 do
    if isHappy(i) then
        file:write(i, "\n")
    end
end
file:flush()
file:close()

chesstiger

Hallo Holger und willkommen im Forum.

Ich persönlich hätte Interesse daran dir unter die Arme zu greifen. Ich habe langjährige Programmiererfahrung muss jedoch gestehen dass meine AutoIt Kenntnisse etwas eingerostet sind. Bin vornehmend mit anderen Programmiersprachen am arbeiten und AutoIt brauchte ich für einige Jahre gar nicht mehr. Sofern du noch keinen anderen gefunden hast können wir uns gerne mal in einen persönlichen Gespräch zusammensetzen. Ich habe lediglich keine Webcam, demnach kann ich nur VoIP anbieten.

Bezüglich der Bezahlung: Pay what you want.

Ich nehme was dir meine Hilfestellung Wert ist. Damit bin ich schon immer gefahren und hab prinzipiell gute Erfahrungen gemacht. Demnach lasse ich dir die Entscheidung wie viel dir meine Hilfestellungen Wert sind.

Falls Interesse besteht kannst du dich hier zurückmelden oder mir einfach eine private Nachricht zukommen lassen. Oder alternativ falls du die Software Discord benutzt kannst du mich dort auch erreichen: Yjuq#3947

Ich persönlich würde prinzipiell erst gar nicht mit den AutoIt Funktionen arbeiten für eine allgemeine UDF. Du kannst schlicht und einfach die WinAPI Funktionen verwenden und entsprechend auch die Event Queue abfragen. Aber ehrlich gesagt habe ich Probleme nachzuvollziehen wieso du dir überhaupt Gedanken um die AutoIt Event Modis machst. Für was soll die UDF denn ausgelegt werden, bzw. Worauf bist du konkret gestoßen dass du dir überhaupt diesen Gedanken machst da eine Unterscheidung machen zu müssen?

Kann aber auch sein dass ich zu lange nicht mehr in AutoIt programmiert habe um die Gründe deiner Fragestellung zu vestehen.

Zitat von sam

[...] was ich nicht wie dann die übersetzung funktioniert [...]

[...] kann mir jemand helfen

Am besten schaust du dir erst einmal wie unsere deutsche Sprache funktioniert. Das hilft nicht nur deinem Übersetzer, sondern hilft dir auch gleichzeitig ordentliche Sätze in einem deutschen Forum zu verfassen. Die einfachste Variante wäre erst einmal ein digitales Wörterbuch zu erstellen. Irgend etwas um Vokabular nachzuschlagen. Darauf lässt sich dann die Grammatik aufbauen.

Welche Funktionalitäten soll dieser "Übersetzer" denn haben?

Zitat von sam

nur weiss ich nicht wo bekomme ich wörterbücher her

Tja, das ist etwas problematisch. Ich hab mal ein wenig im Internet gesucht. Es gibt ein paar zu finden, aber nicht ansatzweise vollständig. Und die großen Firmen (z.B. Langenscheidt, Google, DeepL) bieten keine Downloads ihrer Datenbänke an. Entweder du erstellst ein eigenes oder bindest für den Anfang erst einmal eine Webseite ein, um neue Wörter per HTTP Request abzufragen und dann offline abzuspeichern.

Zitat von blackcho

Eigentlich ist mein Ziel nur Daten aus einer Webseite auszulesen und diese Automatisiert zu verarbeiten.

Wenn das auf nen Raspberry Pi laufen soll dann ist Python vermutlich eher die Scriptsprache die du suchst.

Zitat von SEuBo

Oder ich sage einfach, dass zusätzlich zu einer Include-Anweisung auch noch die Zeile #AutoIt3Wrapper_Run_Before=""%autoitdir%\AutoIt3.exe" "%in%" -Something" eingefügt werden muss, wenn die Leutchens zu faul sind, das Script vor dem Compilen einmal mit F5 zu starten.

Naja, den Tipp wollte ich dir auch erst geben. Aber das hätte deine Frage ja nicht wirklich beantwortet.

Du kannst für die SciTE eine eigene implementation für F7 schreiben. Basierend darauf kannst du eine Start-Skript generieren welche diese Anweisungen beinhaltet und deine Hauptdatei einbindet. Musst halt nur sämtliche include files für diese Anweisungen parsen und in dein Start-Skript schmeißen.

Du kannst diese Implementation entweder in Lua schreiben oder vielleicht durch eine Mischung von AutoIt und der SciTE Config Files herbeiführen. Vielleicht auch Lua + Autoit. Musst dich wohl durch die SciTE Docu durchwühlen.

Zitat von SEuBo

Das Gegenstück zu AutoIt's ObjGet() in Lua würde mir schon reichen

Das würde nicht helfen da Lua COM von sich aus nativ nicht unterstützt.

Da müsstest du schon viel Aufwand betreiben um COM in Lua lauffähig zu bekommen. Da ist es einfacher eine Wrapper Funktion in AutoIt zu deklaieren und diese per Lua aufzurufen um Objekte zu manipulieren.

Aber ich kann es mal probieren ob ich das rohe COM Objekt nicht einfach in Lua als Userdata zur verfügung stelle und dann schaue was passiert. Vielleicht überrascht mich Lua ja und es kann die COM Objekte doch direkt handeln. Das wäre ne ziemliche Überraschung.

Zitat von SEuBo

Über die Jahre habe ich einige Versuche in diese Richtung u.a. mittels Multithreading oder Injection, etc. mitbekommen

Jup, ebenfalls. Multithreading ist zwar möglich aber aufwendig. Du kannst nicht einfach auf Variablen und Funktionen zugreifen die AutoIt zur Verfügung stellt. Da brauchst du schon eigene Mechanismen um alles Thread Safe zu verbasteln. Der Grund ist dass der AutoIt Interpreter intern globale Variablen bei einigen sachen nutzt die schlichtweg das gesamte Konzept über die Bühne schmeißen. GUI + Multithreading ist da schon Problem Nummer 1. Heißt nicht dass solche Dinge nicht funktionieren, aber da muss man halt Umstände in Kauf nehmen von der gewohnten Art in AutoIt zu programmieren. Ich glaube der Aufwand ist einfach schlicht zu groß...

AutoIt hat technisch gesehen keine Limitierungen. Du kommst immer irgendwie drum herum. Die Frage ist nur in wie fern der Aufwand letzten Endes sich für das Vorhaben lohnt. Es existieren zig andere Tools die solche Dinge besser lösen als AutoIt. Da ist es einfacher solch ein Tool statdessen zu benutzen.

Zitat von SEuBo

Die Frage ist und bleibt offen: Wie generiere ich (möglichst elegant) eine AutoIt-Funktion zur Laufzeit?

Was mir noch einfallen würde wäre die Funktionen zu kompillieren mit AutoIt und dann den Funktionscode auszulsen und diese in ausführbaren Memory zu packen in dein laufendes Skript. Etwa so ähnlich wie ein JIT Compiler. Ist nur eine Idee könnte aber funktionieren. Ob das nun "eleganter" ist wage ich zu bezweifeln, aber wäre noch eine Möglichkeit.

Aber da bin ich mir ziemlich unsicher. Ich glaube in einer AutoIt exe wird der Interpreter mitgeliefert und das Skript schlichtweg nur interpretiert. Kann also sein dass die Variante also schon von Vorne herein zum Fehlschlag verleitet ist.

Da sind Varianten über IPC und Multiprocessing durchaus realistischer.

Zitat von SEuBo

Kann ich Plugins zur Laufzeit aktualisieren/nachladen, nachdem schon Module geladen/Funktionen ausgeführt wurden?

Ja, kannst du

In Lua kannst du Funktionen / Variablen / Objekte etc. nach belieben überschreiben und damit auch zur Laufzeit aktualiseren. Hier mal ein sehr vereinfachtes Beispiel:

local function example()
    print("function 1")
end

example()

local function example()
    print("function 2")
end

example()

Entsprechend die Ausgabe:

λ lua54 "c:\Users\Yjuq\Desktop\code.lua"
function 1
function 2

Nur um mal deine Frage oben zu beantworten. Ein Modul ist in Lua nichts weiteres (zumindest meistens) als eine einfache Funktionssammlung. Du kannst also das Ganze "hotpatchen".

Zitat von SEuBo

Da fehlt dann einiges an Routine um flott zu coden - 12 Jahre Erfahrung krieg' ich in Lua demnächst nicht mehr Zusammen.

Lua ist wirklich einfach. Und der Unterschied zu AutoIt ist auch nicht besonders groß. Gib dir ne Woche Zeit um dich einfach mit den Basics zu beschäftigen und du hast das nötigste für Lua drin. Lua hat nicht so viele Features dass du davon überrumpelt werden könntest.

Zitat von SEuBo

Am liebsten hätte ich die Programmiersprache Self - in abgespeckt und ein ganz klein bisschen anders, und simpler - einfach zu verstehen und nutzen im Büro/Enterprise-Kontext.

Lua...

Zitat von SEuBo

Ich bin mit den Services und der Laufzeitumgebung meiner Applikation aber schon weit fortgeschritten und am Point of no Return vorbei - alles noch einmal auf Lua umzubauen,

Ja, das war mir bei meinen ersten Post schon bewusst. Ich sage ja auch nicht alles umbauen, ich sage nur Lua intigrieren für zukünftige Sachen. Was du hast kannst du einfach einbinden. Du brauchst nicht viel umschreiben, lediglich alles was du hast für Lua einmal registrieren. Das war's. Deswegen hab ich dir das ja auch vorgeschlagen.

Zitat von SEuBo

Zugriff auf alle Daten der Applikation gibts quasi automatisch da alles in einem Applikation Objekt liegt, das ich einfach mittels Parameter übergeben kann. Es ist im Prinzip nur die Frage der Eleganz, die ich im ersten Post stelle.

Das du eine funktionierende Lösung hast ist mir auch klar. Selbst mit dieser Information würde ich immernoch Lua vorschlagen...

Lua ist nun perfekt für solche Projekte geeignet. Deswegen schlage ich es ja auch vor. Ob du das eleganter in AutoIt lösen könntest? Keine Ahnung, wenn ROT funktioniert dann reicht es aus.

Hier mal noch ein letztes Beispiel wo ich gerade dran saß:

; ------------------------------------------------------------------------------

#AutoIt3Wrapper_UseX64=n
#include "lua/lua.au3"

; ------------------------------------------------------------------------------

lua("lua/")

Local Const $lua = LuaL_newstate()
luaopen_base($lua)
lua_pop($lua, -1)

; expose our magic functions into lua
lua_pushcfunction($lua, autoit(Null))
lua_setglobal($lua, "autoit")

; ------------------------------------------------------------------------------

Local $var = "autoit"

; first we read the value:
luaL_dostring($lua, "print(autoit('get', 'var'))")

; now change it:
luaL_dostring($lua, "autoit('set', 'var', 'lua')")
ConsoleWrite($var & @CRLF)

; and now we call a function
luaL_dostring($lua, "print(autoit('call', 'callme', 'au3', '<3'))")

Func callme($param1, $param2)
    ConsoleWrite($param1 & @TAB & $param2 & @CRLF)
    Return "success"
EndFunc

; it's not bounded to udfs :P
luaL_dostring($lua, "autoit('call', 'MsgBox', 0, 'title', 'text 1')")

; if you don't like the syntax you can declare wrapper functions in lua:
luaL_dostring($lua, "function MsgBox(flag, title, text) autoit('call', 'MsgBox', flag, title, text) end")
luaL_dostring($lua, "MsgBox(0, 'title', 'text 2')") ; Here the call

; ------------------------------------------------------------------------------

; a magical function in order to manipulate anything for autoit in lua
Func autoit($lua)
    Local Static $func = DllCallbackRegister(autoit, "int:cdecl", "ptr")
    Local Static $ptr = DllCallbackGetPtr($func)
    If $lua = Null Then Return $ptr

    ; get arguments
    Local $arg = getArgs($lua)
    Local $tmp, $i

    Switch $arg[0] ; -> command
        Case "get" ; get autoit value
            $tmp = Eval($arg[1]) ; get value
            pushForLua($lua, $tmp) ; and push it for lua
            Return 1 ; something on the stack
        Case "set" ; set autoit value
            ; arg[1] -> variable to modify
            ; arg[2] -> value to set
            Assign($arg[1], $arg[2])
        Case "call" ; call autoit function
            ; first we build the function call
            $tmp = ""
            For $i = 2 To UBound($arg) - 1
                If IsString($arg[$i]) Then $arg[$i] = '"' & $arg[$i] & '"'
                $tmp &= $arg[$i] & ","
            Next
            $tmp = $arg[1] & "(" & StringTrimRight($tmp, 1) & ")"
            ; and call it
            $tmp = Execute($tmp)
            pushForLua($lua, $tmp) ; return
            Return 1
    EndSwitch

    Return 0
EndFunc


; get the arguments from a function call
Func getArgs($L)
    Local $n = lua_gettop($L) ; number of arguments
    Local $a[$n] ; array for the arguments

    Local $i
    For $i = $n -1 To 0 Step -1
        $a[$i] = fromLuaVal($L)
    Next

    Return $a
EndFunc


; converts a value on the stack for autoit
Func fromLuaVal($L)
    Local $return = Null

    Switch lua_type($L, -1) ; last element on the stack
        Case $LUA_TNUMBER
            $return = lua_tonumber($L, -1)
        Case $LUA_TBOOLEAN
            $return = lua_toboolean($L, -1) = 1
        Case $LUA_TSTRING
            $return = lua_tostring($L, -1)
    EndSwitch

    lua_pop($L, 1)
    Return $return
EndFunc


; push something for lua into the stack
Func pushForLua($lua, $var)
    Switch VarGetType($var)
        Case "Bool"
            lua_pushboolean($lua, $var)
        Case "Int32"
            lua_pushinteger($lua, $var)
        Case "Double"
            lua_pushnumber($lua, $var)
        Case "String"
            lua_pushstring($lua, $var)
        Case "Pointer"
            lua_pushinteger($lua, $var)
        Case Else
            lua_pushnil($lua)
    EndSwitch
EndFunc

; ------------------------------------------------------------------------------

Ich war gerade dabei noch die AutoIt Objekte einzubinden, also eine einfache Funktion die dir ermöglicht auf alle deine vorhandenen AutoIt Objekte zuzugreifen. Die autoit() Funktion ist die Schnittstelle zu den gesamten AutoIt Built-In Funktionen. Ich hab aber leider gerade ein paar Probleme mit dem AutoIt Objekten weil Eval / Assign / Execute für diese bei Zuweisungen nicht so einfach funktionieren. War gerade dabei zu schauen ob ich nicht die Invoke Methode aus dem IDispatch Interface für diese Objekte nicht irgendwie aufrufen könnte.

Um aber mal zurück zu rudern:

Ich bezweifel dass du das mehr eleganter in AutoIt lösen könntest als die Lösung die du momentan hast. Zumindest fällt mir da so nichts mehr dazu ein. Falls das deine Ursprungsfrage eher beantworten sollte. Ich hatte lediglich Lua vorgeschlagen weil es für deine Ansprüche eigentlich eine sehr gute Lösung ist. Vielleicht hat jemand anderes noch eine Idee? Mich wundert es sowieso warum sich hier keiner meldet.

Zitat von SEuBo

Du brauchst nicht genervt zu sein. Das sorgt nicht unbedingt für eine gute Gesprächsgrundlage.

Huh, ich bin nicht genervt. o.o

Ich glaube wir reden nur aneinander vorbei.

Wenn ich genervt wäre würde ich schlichtweg mich verkrümeln und den Thread ignorieren.

Zitat von SEuBo

Dein drittes Beispiel endet in einem Programmabbruch.

Versuch mal #AutoIt3Wrapper_UseX64=y davor zu packen. Da war die Lua UDF noch nicht ganz fertig und ich hatte es nur in 64 bit getestet.

Zitat von SEuBo

Kann ich Plugins zur Lua-Laufzeit nachladen?

Ja? Das ist ja der Sinn dahinter. Schau dir Post #18 nochmal an. Da wird alles direkt geladen und ist direkt global verfügbar. Wenn du ein neues Objekt in deiner GUI anlegst kannst du es auch direkt verwenden ohne Neustart. Das ganze lässt sich auf alles übertragen. Ganze Skripte können geladen und ausgeführt werden zur Laufzeit.

Ich bin gerade noch dabei dir das Beispiel für AutoIt Objekte zu machen.

Mir ist durchaus klar an was für ein Problem du sitzt. Eine Lua integration ist mein erster Vorschlag dafür. Es macht eigentlich genau das was du wünscht. Du kannst das auch (wie bereits gesagt) mit AutoIt und IPC umständlicher lösen. Ist halt nur mehr aufwand und vermutlich mehr Anfälliger für Fehler (wenn dir irgendwelche Prozesse abschmieren etc.)

??? - Ich hab bereits alles beschrieben. Eigentlich waren die ersten Beispielskripte dafür gedacht. Aber okey... Ich schreib dir noch ein Beispiel. <.<

Zitat von SEuBo

Wichtiger wäre mir das hier: RE: Self Modifying Code / IPC / Funktionen zur Laufzeit erzeugen

Huh? Ich hatte doch bereits ein Beispiel geschrieben wie du auf Daten zwischen Lua + AutoIt austauscht. Und auch wie du Funktionen aufrufst. Das war's... Reicht doch aus um ein AutoItObject komplett abzudecken oder nicht? - Oder willst du mir was anderes sagen mit der Verlinkung?

Im Anhang findest du das Beispiel zu deiner GUI mit Lua. Irgendwie ist mir allerdings AutoItObject komplett rausgefallen, es war nicht ansatzweise benötigt. Zumindest für das Minimalbeispiel was du gepostet hattest. Ich hab da paar Kommentare hinterlassen.

Die Objekte welche du in der GUI erstellst sind direkt (ohne Neustart) vorhanden. Also so ziemlich das was du wolltest, abgesehen davon dass du bisher mit AutoItObject das ganze implementiert hast. Was dir bestimmt noch auffallen dürfte ist, dass die include Datei weg ist. Tja... Nicht notwendig. x)

Ich habe versucht dein Orginalbeispiel so weit wie möglich orginal zu lassen. Allerdings war ich am überlegen ob ich es komplett umschreibe. Die Struktur gefällt mir persönlich nicht. Aber ich denke so kannst du dich besser zurechtfinden wenn ich nur an dem nötigsten rumdockter.

Wenn du dich für die Lua Lösung entscheidest sag bescheid. Ich helfe dir da gerne weiter. Ansonsten sehen wir uns bei der AutoIt Variante weiter um. Legacy Support zu den vorhandenen AutoItObjects könnten wir noch intigrieren. Dürfte nicht so schwer sein.

Die Beispiele kratzen nur an der Oberfläche von dem was geht.

Hi, hier ein etwas besseres Beispiel. Die Lua UDF ist jetzt auch fertig (soweit). Ich schaue mir mal das Beispiel an was du da geschickt hast und schreibe dir dann jetzt ein Beispiel mit Lua integration. Ich würde mir schlichtweg wirklich überlegen, ob User Skripte nicht einfach in Lua geschrieben werden könnten. Das würde dein Vorhaben definitiv vereinfachen. Lua ist keine besonders schwere Sprache und du kannst AutoIt Funktionen für Lua Verfügbar machen (siehe Beispiel im Anhang, da hab ich die MsgBox genommen).

Der Vorteil daran ist auch, du kannst mit deinem Hauptprogramm bestimmen auf welche Funktionalität die User überhaupt Zugriff haben. So kann keiner eine AutoIt Funktionen so einfach exploiten. Was du nicht exportierst ist auch nicht verfügbar.

Hi, im Anhang findest du sehr vereinfachte Beispiele um zwischen Lua & AutoIt callbacks / daten auszutauschen. Da geht natürlich um einiges mehr. Allerdings hat mich das schreiben der lua udf einiges an zeit gekostet und sie ist bestimmt noch voller bugs (und unvollständig ^^). Zu dem AutoItObject schreibe ich dir gerne spezifisch auch noch ein Beispiel, aber das sollte dir den groben Einblick geben in wie fern du Lua einbinden könntest. Ich hab nur heute / morgen leider nicht mehr viel Zeit, daher musts du noch aufs Wochenende warten. Viel zu tun

Kannst ja in der Zwischenzeit ein wenig mit dem Gedanken spielen und paar Sachen ausprobieren. Die Lua API Referenz findest du hier:

Lua manual

Scroll einfach runter bist du die ganze Liste mit der "C API" findest.

Das schreit sogar noch mehr nach Lua nach deiner Erklärung und dem Beispielskript welches User anlegen könnten...

Was du vor hast ist AutoIt als embedded Language zu benutzen. Das kannst du knicken ohne komplette Systeme dafür zu intigrieren und IPC zu betreiben. Der Grund dafür ist, dass AutoIt Code nun mal nicht einfach zur Laufzeit geladen und ausgeführt werden kann (mit geteilten Daten). Wenn es nur um Attribut Zuweisungen geht würde ich eher ein einfaches Datenformat vorschlagen was stattdessen geladen wird. Aber da auch Funktionen und Logik vermutlich ausgeführt werden soll wird das ganze kniffliger. Lua ist für solche Vorhaben konzipiert.

Das heißt nicht dass es dafür keine Lösungen gibt, sind aber um einiges aufwendiger als schlichtweg Lua zu intigrieren. Aber bleiben wir mal bei der AutoIt Variante wenn du sagst Lua ist komplett ausgeschlossen. Ich habe gerade nur nicht viel Zeit, deshalb nur eine knappe Antwort. Ich melde mich aber nochmal. o/

€dit:

Zitat

- Nein. Außerdem verstehe ich noch nicht, wie ich das Problem mit den geteilten Daten dann besser löse.

Falls sich doch daran was rütteln lässt kann ich dir gerne ein Beispiel diesbezüglich schreiben. Ist eigentlich nicht so schwierig mit Lua.