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.
-
Kannst du noch den ASM code zu deiner Lösung bereitstellen (oder wie der ungefähr aussah)?
-
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 NCAMany 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 -
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 .
-
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 . 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.290721040534951Meine 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
zu
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:
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
gleich
7. DivisionAh 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:
Geht auch für signed, ist eben bloß ein bissl länger:
7.2 Integer Division mit beliebigen KonstantenViele 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 / dDann 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 / 5f 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:
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:
Jetzt steht da aber noch ein hässliches MUL, das werden wir aber gleich los. Zunächst ein paar Hinweise.
Optimierung IObiger 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!):
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:
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
Alles anzeigen; 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
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:
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 * x0xN 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)
b) |N| < 2^10 - 1 (double precision)
Codemov 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
Alles anzeigen_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
-
-
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.
Bite beschreib mal dein Vorhaben insgesamt. Es gibt sicher 20 bessere Wege als sich mit der IE UDF rumzuschlagen.
-
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)
-
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
Alles anzeigen#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
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>
-
($Toast.foobar)("lol")
Ich wusste doch, dass ich da die richtige Idee hatte. Blödes Au3Check
-
AutoIt
Alles anzeigenGlobal $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
Kennt jemand einen Trick um den Pointer direkt zu callen ohne ihn nochmal irgendwo hin zu kopieren? -
30s? Das interessiert mich jetzt aber auch.
-
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 (bis jetzt schreibe ich Klassen in VB und nutze diese in AutoIt).
-
Aus dem AutoIt 3.1 Source Code:
Ccase 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