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

Beiträge von minx

  • Ich drehe durch ! [arrays vergleichen]

    • minx
    • 28. Mai 2016 um 13:29

    Wenn ein Array über ein literal initialisiert wird, braucht man keine Dimension anzugeben:

    AutoIt
    Global $aFoo[3] = [1, 2, 3]
    Global $aBar = [1, 2, 3] ; ist das selbe
  • Best Practise: Dokumente als Ausgabe generieren

    • minx
    • 14. Januar 2016 um 09:30

    Nimm RTF. Jedes System (Windows, OSX, Unix, Google Docs etc.) unterstützt es, man kann es (gerade aus AutoIt heraus) einfach exportieren und Unterstützung für Logos, Tabellen und was weiß ich hat es auch. Zudem lassen sich RTFs auch wunderbar in PDFs konvertieren, sollte das nötig sein.

  • Börsenduell Runde 2?

    • minx
    • 14. Januar 2016 um 09:03

    Im letzten Börsenduell haben wir die Sinnhaftigkeit von binären Optionen überprüft. BOs haben allerdings mehr mit Wetten als mit echtem Handel zu tun. Diese Runde soll deswegen etwas realitätsnaher sein.

    Idee:

    • Jeder bekommt ein Demo-Konto zugewiesen, auf das ich 25.000€ einzahle. Das Depot with beim ARD Börsenportal geführt und ist kostenlos.
    • Die ARD Kurse sind so ziemlich die schnellsten Updates, die man kostenlos bekommen kann, dennoch zu langsam für Medium- bis High-Frequency-Trading. Deshalb macht es Sinn, den Handel auf "langsamere" Optionen zu beschränken.
    • Als Optionen habe ich mir hier die Endlos-Indexzertifikate von Lang- und Schwartz (aka "Wikifolios") ausgesucht. Mehr Infos dazu gibt es auf der Wikifolio Website. Es sind prinzipiell kleine, von anderen Tradern gemanagete Depots. Der Gesamtkurs dieser Depots (Wikifolios) ist der Wert dieses Zertifikats. Der Vorteil ist, dass diese Zertifikate sowohl eher langsam laufen (heißt: Sich ändern), als auch für Anfänger absolut verständlich und transparent sind.
    • Das "Duell" läuft über mindestens 3 Monate. Disqualifiziert wird: Wer Schulden macht, sein Zugang ändert, andersartige Optionen kauft.
    • Der aktuelle Stand ist immer automatisch über eine dafür von mir eingerichtete Website einsehbar.

    Wer Lust hat mitzumachen möge sich in den nächsten Wochen bei mir melden.

  • Über die String-Dekompression

    • minx
    • 27. Dezember 2015 um 23:15

    @eukalyptus

    Kannst du noch den ASM code zu deiner Lösung bereitstellen (oder wie der ungefähr aussah)?

  • Polizei: Ihr Kind lernt programmieren? Es könnte kriminell sein!

    • minx
    • 12. Dezember 2015 um 14:57

    Um jetzt mal Andy's Kommentar komplett zu ignorieren möchte ich folgendes sagen: Hat jemand eigentlich mal den Artikel (im Original) gelesen? Dort steht als aller erstes, bevor überhaupt sonst die Rede von Programmieren ist folgendes:


    Zitat von NCA

    Many children will have an active interest in coding, spend a lot of time online and have independent learning materials. These are all signs of a healthy and positive interest in computing.
    The UK needs as many people interested in coding as possible. Coding and programming are extremely valuable skills and if your child has an interest you should actively encourage them to do so - but in a lawful way.


    Source: http://www.nationalcrimeagency.gov.uk/crime-threats/…etting-involved

  • Zukunft für AutoIt.de - Impressionen und Ideen

    • minx
    • 7. Dezember 2015 um 18:52

    BTW: Dieser Thread ist immer noch offen für Vorschläge. In wie weit diese machbar sind oder jemals umgesetzt werden ist ein anderes Thema, aber Ideen sind immer gut :) .

  • PartyPlayer

    • minx
    • 3. Dezember 2015 um 07:04

    Das hat überhaupt keine Nebenwirkungen.


    Zitat von Microsoft


    Run-time requirements
    GDI+ can be used in all Windows-based applications. GDI+ was introduced in Windows XP and Windows Server 2003. For information about which operating systems are required to use a particular class or method, see the More Information section of the documentation for the class or method. GDI+ is available as a redistributable for earlier operating systems. To download the latest redistributable, seehttp://go.microsoft.com/fwlink/?LinkID=20993.

  • PartyPlayer

    • minx
    • 2. Dezember 2015 um 10:46
    Zitat von Oscar

    Oh Sorry, aber ich fürchte XP wird nicht unterstützt. Vista ist Minimum!

    Nö, wird es, sogar noch Win2k :D . Du musst bloß die GDIPlus32.DLL herunterladen und per regsvr32 im System registrieren.

  • String von Sonderzeichen befreien

    • minx
    • 27. November 2015 um 15:57
    Zitat von x0r

    Was ich aber nicht wollte, war eine etwas überhebliche Antwort ala "ich bin sowieso toller und kann alles besser".

    Das war keine überhebliche Antwort, nur Fakten:


    Zitat von Bioshade

    Kommt zu exakt dem selben Ergebnis ... nur schneller Getestet über 100.000 Läufe auf der Möhre hier:

    Meins: 0.084690981088042
    Deins: 0.290721040534951

    Meine Funktion war in 99,930% der Fälle schneller - und das bei gleicher Flexibilität


    Hier ist jeder Satz wahr und ist nicht irgendwie agressiv. (Bis auf den Smiley vielleicht, aber wenn dich das ärgert, bist du hier der unreife). Zudem ist es für jeden User, der per Google auf diesen Thread stößt besser, wenn er die saubere, schnellere Variante auch sieht. Denn fürs Filtern ist RegExp da, nicht StringReplace. Das du das nicht kannst interessiert keinen, das wird ja aus deinem ersten Post schon klar. Dann bleibt dir nur übrig was neues zu lernen und dich am gelernten zu erfreuen, statt hier einen Kindergarten zu veranstalten.

    Also Schluss jetzt mit Off-Topic und zurück zum Thema.

  • ASM-Tricks

    • minx
    • 23. November 2015 um 02:43

    Ein paar Notizen zu verschiedenen Geschwindigkeitsoptimierungen die ich mal aus einem älteren Buch abgeschrieben hatte.

    1. LEA

    LEA kann in vielen Fällen einfache Berechnungen ersetzten bzw. zusammenfassen. Z.b. kann man folgenden Code

    Code
    mov eax, ecx
    shl eax, 3
    add eax, ebx
    sub eax, 1000

    zu

    Code
    lea eax, [ebx+8*ecx-1000]

    optimieren.

    2. INC / DEC

    INC und DEC verbrauchen auf so ziemlich allen modernen CPUs eine zusätzliche Mikroinstruktion. Daher lieber ADD / SUB benutzen, damit bleiben nämlich auch alle Flags intakt.

    Besonders interessant wirds hier, wenn ein Loop über eine Struct iteriert. Sofern der Step immer konstant ist, sollte man immer zu ADD greifen um zum Ende der Daten zu springen, statt INC bzw. MUL.

    3. XCHG

    Sollte man generell niemals verwenden. Denn XCHG impliziert ein vorhergehendes LOCK damit alle Threads synchronisiert werden. Das sorgt für kleinere, unnötige Verzögerungen. Wenn es um Dateigröße statt Speed geht, spart man mit XCHG hier und da auch ein ein Byte.

    4. Bit Tests

    Diese sind bis heute auf AMD CPUs nicht optimal umgesetzt und verursachen immer 2 zusätzliche Mikroinstruktionen (im Folgenden µOps). Hier lieber selbst mit TEST und bitwise Logik Hand anlegen. Wenn nur wenig getestet wird ists aber halb so schlimm.

    5. L/SAHF

    Wieder langsam auf AMD CPUs. Dort statt LAHF einfach mit SETcc arbeiten. Auf jeder CPU kann man SAHF durch TEST ersetzen, wenn nur auf ein Bit in AH geprüft werden soll.

    Nützlich ist auch FCOMI, dann dies hier:

    Code
    FCOM
    FNSTSW AX
    SAHF

    kann einfach durch ein FCOMI ersetzt werden. FCOMI kann man an äußerst vielen anderen Stellen benutzen um FPU Berechnungen zu optimieren, aber das erklären andere Tutorials besser.

    6. Integer Multiplikation

    MUL (und IMUL) sollte generell komplett vermieden werden und ist in jedem Fall durch schnelleren Code ersetzbar, so lange ein Faktor konstant ist. So ist

    Code
    IMUL EAX, 5

    gleich

    Code
    LEA EAX, [EAX+4*EAX]


    7. Division

    Ah ja, mein Lieblingsthema.

    7.1 Integer Division mit 2^N

    Das ist ein Spezialfall, der sich gut optimieren lässt. Hier kann man sogar gleichzeitig für Größe optimieren wenn man sich auf unsigned beschränkt:

    Code
    shr EAX, N

    Geht auch für signed, ist eben bloß ein bissl länger:

    Code
    ; Divide signed ints by 2^N
    cdq
    and EDX, (1 shl N) - 1
    add EAX, EDX
    sar EAX, N


    7.2 Integer Division mit beliebigen Konstanten

    Viele Wege führen nach Rom. Ich beschreibe hier mal den Mathisen Algorithmus. Dieser wird verwendet um ASM Code zu konstruieren, der nicht nur für die jeweilige Konstante optimiert ist, sondern auch auf die Breite (ie. wie viel Bit) der Zahl.

    Unsere Konstante ist d. Daraus erechnen wir mal folgende Zahlen:

    b = (signifikante bits in d) - 1
    r = w + b
    f = 2^r / d

    Dann ergeben sich drei Fälle, die letztendlich den Code vorgeben:

    Fall A, f ist ein Integer (frac(f) = 0)

    • Ergebnis = x SHR b


    Fall B, frac(f) < 0.5

    • f abrunden
    • Ergebnis = ((x + 1) * f) SHR r


    Fall C, frac(f) > 0.5

    • f aufrunden
    • Ergebnis = (x * f) SHR r


    Eigentlich ganz einfach. Aufgepasst: Das ist nur der erste Schritt. Nachdem wir hier fertig sind, müssen wir trotzdem noch alle oben genannten Optimierungen anwenden (z.B. das MUL loswerden).

    Exerzieren wir das mal durch. Wir wollen (EAX) durch 5 teilen:

    5 = 101b
    w = 32 (ie. die Breite in bits)
    b = 1 (da 5 drei signifikante bits hat - 1)
    r = 32 + 2 = 34
    f = 2^34 / 5

    f ist also 3435973836.8. Da frac(f) = 0.8 > 0.5 müssen wir Fall C anwenden, also runden wir f auf 0CCCCCCCDh auf.

    Also folgender simpler Code:

    Code
    ; x liegt als Wert in EAX
    mov EDX, 0CCCCCCCDh           ;
    mul EDX                       ; x * f
    shr EDX, 2

    Warum nur SHR EDX, 2? Weil das Ergebnis in EDX schon um 32bits geshifted vorliegt. Somit brauchen wir nur noch um b zu shiften. Das Ergebnis liegt jetzt in EDX.

    Für den Fall B ergibt sich folgender Code:

    Code
    add EAX, 1
    mov EDX, f
    mul EDX
    shr EDX, b

    Jetzt steht da aber noch ein hässliches MUL, das werden wir aber gleich los. Zunächst ein paar Hinweise.




    Optimierung I

    Obiger Code schließt leider x = 0FFFFFFFFh aus, da durch das ADD ein Overflow ensteht. Das lässt sich wie folgt umgehen (sollte man NUR einbauen, wenn man einen Overflow erwartet!):

    Code
    mov EDX, f
    	add EAX, 1
    	jc overflow
    	mul EDX
    overflow:
    	shr EDX, b

    Optimierung II

    Es ergibt Sinn r kleiner zu wählen. Wenn nämlich r = w = 32, dann kann der letzte shift einfach weg :)

    Optimierung III

    Man kann auch mit IMUL was erreichen. Das hat den Vorteil, dass es vieles vom obigen Code einfach in einem Schritt erledigt, aber mit niedrigerer Präzision. Wenn also r = 16 + b, dann geht es ganz simpel:

    Code
    ; Dividieren durch 5
    imul eax, 0CCCDh
    shr EAX, 18

    Optimierung IV

    Vielleicht ist es schon aufgefallen, aber wenn man zwischen B und C wählen kann, sollte man immer so rechnen, dass man C verwendet. Warum? Weil man sich ein ADD spart. Dafür muss wieder r intelligent gewählt werden. So. Und nun optimieren wir noch das MUL weg und shiften stattdessen.

    Dazu ein Beispiel. Wir wollen 1.) durch 10 teilen mit 2.) niedriger Präzision für mehr Speed und 3.) das Ergebnis in EAX statt EDX:

    Code
    ; f = 2^17 / 10 = 3333h
    ; -> Fall B, also (x + 1) * 3333h
    ; Ergebnis wird hier zurück in EAX geschrieben
    ; Multiplikation wurde hier schon wegoptimiert
    
    
    lea EBX, [EAX+2*EAX+3]
    lea ECX, [EAX+2*EAX+3]
    shl EBX, 4
    mov EAX, ECX
    shl ECX, 8
    add EAX, EBX
    shl EBX, 8
    add EAX, ECX
    add EAX, EBX
    shr EAX, 17
    Alles anzeigen


    Optimierung V

    Das waren die Grundlagen, jetzt wollen wir mal mehrere Zahlen auf einmal teilen. Als Beispiel werden hier 8 unsigned 16bit Integer durch 100 geteilt:

    Code
    .data
    align 16
    HDIV dw 8 dup (0CCCDh)
    
    
    .code
    pmulhuw xmm0, HDIV
    psrlw xmm0, 3

    Optimierung VI

    Logischerweise kann man damit jede Division beschleunigen, die wiederholt mit einer Konstante ausgeführt wird. In Loops z.B.. Dann einfach einmal obige Zwischenergebnisse ausrechnen und den Code anpassen. Wie man das im Algorithmen Design umsetzt ist hier erklärt.

    Optimierung VII

    Fast geschafft. Nur noch ein kurzer Exkurs mit SSE. Wenn man obige Methode auf SSE anwendet hat man normalerweise nur 12bit zur Verfügung. Intel hat dazu aber eine Empfehlung ausgesprochen (siehe AP-803), wie man mit dem Newton-Raphson Verfahren nochmal was rausholt um auf 23bits zu kommen. Die Berechnung dazu sieht so aus:

    x0 = rcpss(d)
    x1 = x0 * (2 - d * x0) = 2 * x0 - d * x0 * x0

    xN ist hier die N-beste Annäherung an das Reziproke von d.

    Umgesetzt wirds so:

    Code
    ; Ergebnisse werden in xmm0 stehen
    movaps xmm1, [divisors]
    rcpps xmm0, xmm1
    mulps xmm1, xmm0
    mulps xmm1, xmm0
    addps xmm0, xmm0
    subps xmm0, xmm1
    mulps xmm0, [dividends]

    Das sind 4 23bit Divisionen in 18 Takten.


    8. Exponenten in Kommazahlen

    BTW. FSCALE immer vermeiden, einfach direkt in die Exponentenbits schreiben.

    Für alle 2^N (N ist signed) gilt folgendes:

    a) |N| < 2^7 - 1 (single precision)

    Code
    mov EAX, [N]
    shl EAX, 23
    add EAX, 3f800000h
    mov dowrd ptr [TEMP], eax
    fld dword ptr [TEMP]

    b) |N| < 2^10 - 1 (double precision)

    Code
    mov EAX, [N]
    shl EAX, 20
    add EAX, 3ff00000h
    mov dword ptr [TEMP], 0
    mod dword ptr [TEMP+4], EAX
    fld qword ptr [TEMP]

    Und schon können wir eine allgemeine, schnelle und (so ziemlich) bug-freie Exponentialfunktion mit double-Genauigkeit ableiten:

    Code
    _exp PROC NEAR
    PUBLIC _exp
    		fldl2e
    		fld qword ptr [esp+4]             ; x
    		fmul                              ; z = x*log2(e)
    		fist dword ptr [esp+4]            ; round(z)
    		sub esp, 12
    		mov dword ptr [esp], 0
    		mov dword ptr [esp+4], 80000000h
    		fisub dword ptr [esp+16]          ; z - round(z)
    		mov eax, [esp+16]
    		add eax,3fffh
    		mov [esp+8],eax
    		jle short UNDERFLOW
    		cmp eax,8000h
    		jge short OVERFLOW
    		f2xm1
    		fld1
    		fadd                              ; 2^(z-round(z))
    		fld tbyte ptr [esp]               ; 2^(round(z))
    		add esp,12
    		fmul                              ; 2^z = e^x
    		ret
    UNDERFLOW:
    		fstp st
    		fldz                              ; return 0
    		add esp,12
    		ret
    OVERFLOW:
    		push 07f800000h                   ; +infinity
    		fstp st
    		fld dword ptr [esp]               ; return infinity
    		add esp,16
    		ret
    _exp ENDP
    Alles anzeigen
  • Screenshot von nicht sichtbaren IE-Fenster

    • minx
    • 15. November 2015 um 08:57
    Zitat von alpines

    Ich muss es ja nicht sehen um es zu zeichnen.

    In Windows eben schon. Zumindest der klassische weg über ein einfaches Blitten ist nicht möglich. Denn jedes Fenster (und jeder Bereich von Fenstern), der nicht sichtbar ist, hat auch keinen gefüllten Device Context.

    @MrB

    Bite beschreib mal dein Vorhaben insgesamt. Es gibt sicher 20 bessere Wege als sich mit der IE UDF rumzuschlagen.

  • Frage an Sprayer / Airbrush / Maler / Farbenspezialisten

    • minx
    • 15. November 2015 um 08:53
    Zitat von Andy

    Im Prinzip ein überdimensionaler Tintendrucker, der je nach Position des Druckkopfes einen Farbklecks auf die Wand "malt".

    Genauso sollte man das auch machen, Airbrush ist dafür total ungeeignet. Ein schwebender Druckkopf wird normalerweise dafür eingesetzt, die Modifikation ist recht einfach: Printer (3D, 2010)

  • Random ohne Wiederholung - Wie geht's am einfachsten?

    • minx
    • 9. November 2015 um 16:09
    Zitat von BugFix

    Du übergibst an die Funktion als Parameter den Zahlenbereich und die gewünschte Anzahl an Zufallszahlen. Das Ergebnis gibt die Funktion als kommagetrennten String (Standard) oder als Array (Parameter $array=1) zurück.

    Unnötige Beschränkung, dafür gibt es doch Static:

    AutoIt
    #include <Array.au3>
    
    
    
    
    ; Funktion testen
    Local $aTest[Null]
    
    
    For $iN = 1 To 10
    	_ArrayAdd($aTest, _Random(1, 10, 1))
    Next
    
    
    _ArraySort($aTest)
    _ArrayDisplay($aTest)
    
    
    ; Random funktion (selber Syntax wie AutoIt).
    Func _Random($iMin = 0, $iMax = 1, $iInt = 0)
    	Local Static $n
    	Local $t = [$iMin-1, UBound($n), $iMin-1]
    	If $t[1]+1 > $iMax Then Return SetError(1, 0, -1)
    	If UBound($n) Then
    		While $t[0] = $t[2]
    			$t[0] = Random($iMin, $iMax, $iInt)
    			For $k = 0 To $t[1]-1
    				$t[0] = $n[$k] = $t[0] ? $t[2] : $t[0]
    			Next
    		WEnd
    		ReDim $n[$t[1]+1]
    		$n[$t[1]] = $t[0]
    		Return $n[$t[1]]
    	EndIf
    	Local $t = [Random($iMin, $iMax, $iInt)]
    	$n = $t
    	Return $n[0]
    EndFunc
    Alles anzeigen

    Edit: Error Handling hinzugefügt.

  • Display filmen (erledigt)

    • minx
    • 8. November 2015 um 02:39

    Wenn es etwas einfacher sein soll kann ich nur "Icecream Screen Recorder" empfehlen. Ich habe mich dafür von CamStudio verabschiedet, da selbiges im letzten Jahrhundert hängengeblieben ist.

    Das Programm ist klein, übersichtlich, ressourcensparend und hat sinnvolle Shortcuts.

  • Funktionspointer in Maps?

    • minx
    • 15. Oktober 2015 um 22:41
    Zitat von Mars

    Maps für soetwas zu missbrauchen

    DLLStructs darf man nicht für Fake-Klassen misbrauchen (sagte selbst trancexx). Maps aber sind Kontrukte, die Daten enthalten. Wenn man denn schon einen Funktionspointer hat, dann darf ich den doch wohl auch benutzen. Die ganze "die Sprache misbrauchen" Mentalität geht mir im anderen Forum langsam auf die Nerven.

    </rant>

  • Funktionspointer in Maps?

    • minx
    • 15. Oktober 2015 um 22:33
    Zitat von Mars

    ($Toast.foobar)("lol")

    Ich wusste doch, dass ich da die richtige Idee hatte. Blödes Au3Check ^^

  • Funktionspointer in Maps?

    • minx
    • 15. Oktober 2015 um 19:54
    AutoIt
    Global $Toast[]
    
    
    $Toast.foobar = foobar
    
    
    ; funzt nicht
    ;~ $Toast.foobar("lol")
    
    
    ; funzt?!
    $n = $Toast.foobar
    $n("lol")
    
    
    ; funzt nicht
    ;Call("$Toast.foobar")
    
    
    ; funzt...
    ConsoleWrite(IsFunc($Toast.foobar) & @LF)
    
    
    ; funzt!
    Global $o = [$Toast.foobar]
    $o[0]("array")
    
    
    Func foobar($s = 'default')
    	MsgBox(0,0,$s)
    EndFunc
    Alles anzeigen


    Kennt jemand einen Trick um den Pointer direkt zu callen ohne ihn nochmal irgendwo hin zu kopieren?

  • MD5 Hasher optimieren | 0xf Level 20

    • minx
    • 8. Oktober 2015 um 22:47

    30s? Das interessiert mich jetzt aber auch.

  • NativeAutoItObjectEx (Objekte in AutoIt)

    • minx
    • 21. September 2015 um 02:57

    Irgendwie muss der erste Parameter bei Methoden weg. Eine Instanz muss sich (irgendwie) von alleine abgrenzen, ohne dass der User noch extra daran denken muss.

    Dann kann ich mich endlich von VB6 verabschieden :D (bis jetzt schreibe ich Klassen in VB und nutze diese in AutoIt).

  • AutoIt und redirected Desktop

    • minx
    • 23. August 2015 um 04:05

    Aus dem AutoIt 3.1 Source Code:

    C
    case M_DESKTOPDIR:
    			Util_RegReadString(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", "Desktop", _MAX_PATH, szValue);
    			vResult = szValue;
    			break;


    Und hier ist der Code für alle anderen Makros: http://pastebin.com/HCascSC6

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™