Beiträge von minx

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

Global $aFoo[3] = [1, 2, 3]
Global $aBar = [1, 2, 3] ; ist das selbe

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.

@eukalyptus

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

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.

Zitat von Oscar

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.

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.

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

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

zu

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:

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

IMUL EAX, 5

gleich

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:

shr EAX, N

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

; 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:

; 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:

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!):

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:

; 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:

; 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:

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

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

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)

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:

_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

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.

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)

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:

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

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>

Zitat von Mars

($Toast.foobar)("lol")

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

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

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:

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