Beiträge von minx

    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.

    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.

    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…ple-from-getting-involved

    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.

    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.

    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:



    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.

    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
    1. mov eax, ecx
    2. shl eax, 3
    3. add eax, ebx
    4. sub eax, 1000

    zu

    Code
    1. 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
    1. FCOM
    2. FNSTSW AX
    3. 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
    1. IMUL EAX, 5

    gleich

    Code
    1. 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
    1. shr EAX, N

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


    Code
    1. ; Divide signed ints by 2^N
    2. cdq
    3. and EDX, (1 shl N) - 1
    4. add EAX, EDX
    5. 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
    1. ; x liegt als Wert in EAX
    2. mov EDX, 0CCCCCCCDh ;
    3. mul EDX ; x * f
    4. 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
    1. add EAX, 1
    2. mov EDX, f
    3. mul EDX
    4. 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
    1. mov EDX, f
    2. add EAX, 1
    3. jc overflow
    4. mul EDX
    5. overflow:
    6. 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
    1. ; Dividieren durch 5
    2. imul eax, 0CCCDh
    3. 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:




    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
    1. .data
    2. align 16
    3. HDIV dw 8 dup (0CCCDh)
    4. .code
    5. pmulhuw xmm0, HDIV
    6. 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
    1. ; Ergebnisse werden in xmm0 stehen
    2. movaps xmm1, [divisors]
    3. rcpps xmm0, xmm1
    4. mulps xmm1, xmm0
    5. mulps xmm1, xmm0
    6. addps xmm0, xmm0
    7. subps xmm0, xmm1
    8. 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
    1. mov EAX, [N]
    2. shl EAX, 23
    3. add EAX, 3f800000h
    4. mov dowrd ptr [TEMP], eax
    5. fld dword ptr [TEMP]


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


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


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


    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.

    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:


    Edit: Error Handling hinzugefügt.

    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.

    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>


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

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