Beiträge von Mars

Wenn du es richtig geschmeidig haben willst musst du die Float-Positionen bestmöglich durch Int-Positionen approximieren. Also wenn ich z.B. 10x um 0.5 Pixel bewege nimmt man 0 1 0 1 0 1 0 1 0 1 und nicht (wie aktuell mit einfachem Abrunden) 0 0 0 0 0 0 0 0 0 0.

Klingt weeeesentlich schwieriger als es ist. Einfach einen Positionspuffer erzeugen in dem der "Rest hinter dem Komma" aufgehoben wird.

Global $aFloatPos = [0, 0]


$aFloatPos[0] += 5 * Sin(TimerDiff($t) / 1000) + 3 * Cos(TimerDiff($t) / 3000)
$aFloatPos[1] += 5 * Cos(TimerDiff($t) / 1000) + 3 * Sin(TimerDiff($t) / 7000)
$iTimer = TimerInit()
_ED2D_BitmapMove($hIMG, $hIMG2, Int($aFloatPos[0]), Int($aFloatPos[1]))
$iTime = (TimerDiff($iTimer) + $iTime * 19) / 20
$aFloatPos[0] -= Int($aFloatPos[0])
$aFloatPos[1] -= Int($aFloatPos[1])

Zu GDI+:
Das einzige was hier fehlt ist der VSync. Gäbe es eine Funktion (wie in D2D) die passend zur Bildfrequenz zeichnet (Es gibt leider keine mit bekannte Methode das in GDI+ zu fabrizieren), hätte man 90% Des Ruckelns abgeschafft, da man als Programmierer etwas aufpassen kann, dass das Skript die 60 oder 30 FPS schafft. (Bei niedrigeren Frameraten ist das Tearing eher Nebensache).
Man kann mit D2D (manche, viele, alle, keine ?) Bitmaps aus GDI+ (via Scan0 geht "meistens", da man hier das RAM kopieren kann... können sollte.... hust.... Pixelformatfehler obwohl nur Integer im RAM liegen !?) kopieren und dann als D2D Bitmap ins Fenster beamen, das habe ich an einigen Stellen bereits ausprobiert, eine allumfassend zufriedenstellende Lösung gibt es (von mir jedenfalls) noch nicht.

Edit: Das Problem ist nichtmal neu.... Das hab ich mir vor 3 Jahren schon gestellt. Inzwischen ist aber (dank eukalyptus und seinem D2D-Elan) wenigstens ein Ziel in Sicht

lg
M

Das Tearing liegt am fehlenden VSync.
Hab dir mal kurz eine D2D Version gebaut, da ist es nur noch wegen den Integern abgehackt, aber 0% Tearing

Edit1: Dabei ist mir aufgefallen, dass D2D keine negativen Koordinaten mag. Daher hab ich es kurzerhand einfach mit Max(..., 0) gelöst. Das Ergebnis ist nun exakt gleich mit dem von GDI+

Edit2: Im Prinzip ist die Variante mit Max sogar wesentlich besser. Dort wird nämlich nur der benötigte Bildausschnitt gezeichnet, und wie ich GDI+ kenne wird da nicht intern geschaut welches Rechteck vom Quellbild man benötigt, sondern Pixel für Pixel jedes Mal eine IsInRect Routine (die selbstverständlich ein eigenes Handle im Kernel bekommt, sonst wäre das ja eine schnelle Sache) aufgerufen. ggf ist also noch etwas Beschleunigung von GDI+ drin, leider ist es Spät und ich will schlafen...^^

lg
M

Moin,

Es ist wieder nur eine sehr kleine Funktion für GDI+ von der ich nicht weiß ob ich sie in dieser Form schonmal im Forum gesehen habe. Der Übersicht halber hat sie jetzt einen eigenen Thread, falls sie jemand sucht. Das Prinzip der Funktion ist bekannt, aber ehe Irgendwer Workarounds fabriziert, lieber den einfachen Weg wählen

Was kann die Funktion:
- Das berühmte "Links rein, Rechts raus" Prinzip auf Bitmaps anwenden.
- Das Bild "verschmierfrei" behandeln. (Ist 2x abgesichert. Wer das nicht will nimmt Round heraus und ändert die Zeichenfunktion von int zu float.)
- mehr nicht.

Im Anhang ist eine Zip versehen mit der Funktion selbst und einem Anwendungsbeispiel.

Func _GDIPlus_BitmapMove($hBMP, $dx, $dy)
	$dx = Round($dx, 0)
	$dy = Round($dy, 0)
	Local $iW = DllCall($__g_hGDIPDll, 'int', 'GdipGetImageWidth', 'handle', $hBMP, 'uint*', 0)[2]
	Local $iH = DllCall($__g_hGDIPDll, 'int', 'GdipGetImageHeight', 'handle', $hBMP, 'uint*', 0)[2]
	Local $hClone = DllCall($__g_hGDIPDll, 'int', 'GdipCloneBitmapAreaI', 'int', 0, 'int', 0, 'int', $iW, 'int', $iH, 'int', 0x00021808, 'handle', $hBMP, 'handle*', 0)[7]
	Local $hGFX = DllCall($__g_hGDIPDll, 'int', 'GdipGetImageGraphicsContext', 'handle', $hBMP, 'handle*', 0)[2]
	Local $iX = Int($dx / $iW) * $iW + $dx, $iY = Int($dy / $iH) * $iH + $dy, $tX = $dx < 0 ? $iW : -$iW, $tY = $dy < 0 ? $iH : -$iH
	DllCall($__g_hGDIPDll, 'int', 'GdipDrawImageI', 'handle', $hGFX, 'handle', $hClone, 'int', $iX, 'int', $iY)
	DllCall($__g_hGDIPDll, 'int', 'GdipDrawImageI', 'handle', $hGFX, 'handle', $hClone, 'int', $iX + $tX, 'int', $iY)
	DllCall($__g_hGDIPDll, 'int', 'GdipDrawImageI', 'handle', $hGFX, 'handle', $hClone, 'int', $iX, 'int', $iY + $tY)
	DllCall($__g_hGDIPDll, 'int', 'GdipDrawImageI', 'handle', $hGFX, 'handle', $hClone, 'int', $iX + $tX, 'int', $iY + $tY)
	DllCall($__g_hGDIPDll, 'int', 'GdipDeleteGraphics', 'handle', $hGFX)
	DllCall($__g_hGDIPDll, 'int', 'GdipDisposeImage', 'handle', $hClone)
EndFunc

lg
M

Das sieht doch schon sehr gut aus. Damit es etwas Portabel einsetzbar ist sollte man das Gebilde noch in eine Funktion packen.

Local $aID = ['IDs'], $aType = ['Types'], $aName = ['Names'], $aPrice = ['Prices']


_IniToArray('Datei.ini', $aID, $aType, $aName, $aPrice)


_DumpArray($aID)
_DumpArray($aType)
_DumpArray($aName)
_DumpArray($aPrice)


Func _DumpArray($array)
	ConsoleWrite($array[0] & @CRLF)
	For $i = 1 To UBound($array) - 1
		ConsoleWrite($array[$i] & @CRLF)
	Next
EndFunc


Func _IniToArray($sPath, ByRef $aID, ByRef $aType, ByRef $aName, ByRef $aPrice)
	Local $aSections = IniReadSectionNames($sPath), $u = $aSections[0], $aKeys
	ReDim $aID[$u + 1], $aType[$u + 1], $aName[$u + 1], $aPrice[$u + 1]
	For $i = 1 To $u Step 1
		$aKeys = IniReadSection($sPath, $aSections[$i])
		$aID[$i] = $aKeys[1][1]
		$aType[$i] = $aKeys[2][1]
		$aName[$i] = $aKeys[3][1]
		$aPrice[$i] = $aKeys[4][1]
	Next
EndFunc

lg
M

Ich weiß wirklich nicht genau was du willst.

Hab jetzt eine Funktion gebastelt die die Zeichen in einem Text zufällig anordnet. Die Funktion geht in beide Richtungen.

Local $sText = 'Hallo, ich bin ein Text. Hier könnte alles mügliche stehen...'
Local $sMixed = Mix($sText)
Local $sUnMixed = Mix($sMixed, True)


ConsoleWrite('Original:      ' & $sText & @CRLF & 'Gemischt:      ' & $sMixed & @CRLF & 'Entwurschtelt: ' & $sUnMixed & @CRLF)


Func Mix($sString, $bUnmix = False)
	Local $aString = StringToASCIIArray($sString), $iUbound = UBound($aString), $aRnd[$iUbound], $iTmp
	For $i = 0 To $iUbound - 1 Step 1
		$iTmp += $aString[$i]
	Next
	SRandom($iTmp)
	For $i = 0 To $iUbound - 1 Step 1
		$aRnd[$i] = Random(0, $iUbound - 1, 1)
	Next
	For $i = ($bUnmix ? ($iUbound - 1) : 0) To ($bUnmix ? 0 : ($iUbound - 1)) Step ($bUnmix ? -1 : 1)
		$iTmp = $aString[$i]
		$aString[$i] = $aString[$aRnd[$i]]
		$aString[$aRnd[$i]] = $iTmp
	Next
	Return StringFromASCIIArray($aString)
EndFunc

Edit: Was "Random" angeht. Ich verstehe nicht was damit gemeint ist. Random ist nur Pseudozufällig, sodass man mit SRandom jedes Ergebnis rekonstruieren kann. Mein Beispiel benutzt zwar Random, ist aber dennoch vollständig deterministisch.

lg
M

Moin,

Ich habe 2x einen Dell Ultrasharp 24" mit 1920x1200 nebeneinander und noch einen kleinen 1440x900 Monitor. Die 16:10 gefallen mir bei nebeneinander stehenden Bildschirmen wesentlich besser als 16:9, aber ich bin eh ein 16:10 Fanatiker, das ist jedem selbst überlassen. Da meine Graka nicht übermäßig gut ist, hat man mit der "niedrigen" Auflösung von "nur" 1920x1200 trotzdem eine anständige Framerate beim Spielen, die ich mit Bildschirmen höherer Auflösung garantiert nicht hätte.

lg
M

Sieht mir nach XY-Problem aus.

Problem: Nicht näher erläutert (X)
Vermeintliche Lösung: Maus (aber nicht Tastatur) blockieren + Mousemove + Mouseclick (Y)
Frage im Forum nach (Y)
Eigentlich zu Lösendes Problem (X)

Erkläre bitte möglichst genau (vllt mit Screenshot) was du tun möchtest. Man kann nahezu auf alle Fenster direkt zugreifen (es gibt zwar immer irgendwelche Querschläger die sich selbst eine Oberfläche zusammenfriemeln die keinen sinnvollen Zugang hat, aber das ist die Ausnahme).

Edit: Hast du schon versucht via WindowTool an die Ctrls zu kommen ?

lg
M

Jop. Mit der Polarmethode lassen sich "echt" Normalverteilte Zufallszahlen erzeugen. Meine Methode ist eine Variation der 12er Regel, die nur annähernd eine Normalverteilung liefert. Welche der Methoden man anwendet ist im Regelfall wahrscheinlich egal.

Damit können sich Leser des Threads direkt über 2 Lösungen freuen

lg
M

Moin,
Es ist nur eine sehr kleine Funktion, aber ab und zu taucht die Frage wieder auf: Wie kann man mit der BuildIn Random-Funktion eine halbwegs anständige Normalverteilung zustandebringen ?

Der Trick ist, einfach mehrere (wir nehmen hier eine Gleichverteilung an) BuildIn-Randoms zu addieren und mit einem Korrekturfaktor (damit die Standardabweichung stimmt) zu versehen. In diesem Fall werden 6 float Zufallszahlen aus dem Bereich (-1, 1) verwendet, damit ist ein Maximalabstand zum Mittelwert von 6 Sigma möglich. (eine "echte" Normalverteilung hat selbstverständlich keine Beschränkung, allerdings kommen Ereignisse außerhalb von 6 Sigma nicht besonders häufig vor).

Als kleine Info: 1x Random -> Gleichverteilt, 2x Random -> "Dreieck", 3x Random -> Normalverteilung mit "Knicken", 6x Random -> Normalverteilung mit vielen, aber weniger ausgeprägten "Knicken".

#include <Array.au3>


Local $n = 100000, $aRnd[$n] ; 100.000 Testzahlen


For $i = 0 To $n - 1 Step 1
	$aRnd[$i] = RandomN(30, 20) ; Mittelwert 30, Standardabweichung 20
Next


Local $aStdAbw = StdABW($aRnd) ; Mittelwert und Standardabweichung berechnen


ConsoleWrite('Mid:    ' & $aStdAbw[0] & @CRLF & 'StdABW: ' & $aStdAbw[1] & @CRLF) ; Ausgabe


_ArrayDisplay($aRnd, 'Zufallszahlen', 25) ; Erste 25 Elemente anschauen


; #FUNCTION# ====================================================================================================================
; Author ........: Mars
; Description ...: Berechnet den Mittelwert und die Standardabweichung.
; ===============================================================================================================================
Func StdABW(ByRef $aArray)
	Local $n = UBound($aArray), $nMid = ArraySum($aArray)/$n, $nVar = 0
	For $i = 0 To $n - 1 Step 1
		$nVar += ($aArray[$i] - $nMid)^2
	Next
	Local $aRet = [$nMid, ($nVar / ($n - 1)) ^ 0.5]
	Return $aRet
EndFunc


; #FUNCTION# ====================================================================================================================
; Author ........: Mars
; Description ...: Ermittelt einen Zufallswert anhand eines gegebenen Mittelwertes und der Standardabweichung
; ...............: Obacht! Es handelt sich um KEINE richtige Normalverteilung, sondern nur um eine Näherung!
; ===============================================================================================================================
Func RandomN($nMid, $nSigma) ; Es können nur Ereignisse im 6 Sigma Bereich auftreten.
	Return $nMid + $nSigma * (Random(-1, 1) + Random(-1, 1) + Random(-1, 1) + Random(-1, 1) + Random(-1, 1) + Random(-1, 1)) / 1.414214
EndFunc


; #FUNCTION# ====================================================================================================================
; Author ........: Mars
; Description ...: Summiert alle Elemente eines Arrays
; ===============================================================================================================================
Func ArraySum($aArray)
	If Not IsArray($aArray) Then Return $aArray
	Local $iTmp = 0
	For $i = 0 To UBound($aArray) - 1 Step 1
		$iTmp += $aArray[$i]
	Next
	Return $iTmp
EndFunc

Hier ist ein kleines Beispiel wie die Verteilung mit der Funktion aussehen könnte (so "glatt" ist sie nur, wenn man entsprechend viele Zufallszahlen generiert. Mittelwert = 50, Standardabweichung = 12.5)
Plot.png

Edit: In Post 3 gibt es noch eine Variante für die Erzeugung zweier Normalverteilter Zufallsvariablen, die eine echte Normalverteilung liefert.

lg
M

Ich würde von diesem Vorhaben absehen.

Für Erkennungssoftware sind immer mehrere Faktoren ausschlaggebend. Man benötigt für eine gute Rate möglichst viele verschiedene eigenständige Erkennungsmethoden die jeweils die subjektive Wahrscheinlichkeit für einen Treffer zurückgeben. Diese werden dann gewichtet zusammengerechnet um so eine Gesamtwahrscheinlichkeit (für ein einziges Korn) zu finden. Mir fällt aber keine "einfache" Methode ein (also keine Methode die man "mal eben" hinschreibt).

Meine Idee wäre:
Das "Durchschnittskorn" von Hand erzeugen. Also z.B. 50 geschlossene/offene Körner zu einem Bild überlagern. Dieses Bild wird vom Programm automatisch gedreht und Skaliert und mit den Körnern auf dem Foto vergleichen. Da man 2 Durchschnittsbilder hat, kann man für beide eine Prozentuale übereinstimmung angeben (obacht, das geht jeweils von 0 bis 100%, also muss man beide Werte durch 2 Teilen. Dann bekommt man sowas in der Art: Offen: 45%, Geschlossen: 22%, Sonstiges = 100% - (Offen + Geschlossen) = 33%. Daraus kann man mit einer gewissen Unsicherheit darauf schließen, dass das untersuchte Korn offen ist. (Oder man normiert auf andere Weise. Ausgangswert war Offen = 90%, Geschlossen = 44%. -> Offen mit 1-90%/(90%+44%)=33% Irrtumswahrscheinlichkeit. Bin mir aber nicht sicher wie man Wahrscheinlichkeiten in diesem Fall auslegen muss, da muss ein Fachmann ran^^)

Das zu programmieren ist aber nicht so leicht wie es auf den ersten Blick klingt...

Falls du vorhast größere Mengen an Dateien zu speichern ist ein Random mit 4 Stellen ggf. ungeeignet. Zudem unterscheidet Windows nicht zwischen groß und Kleinschreibung.

Beispiel: (Falls ich mich verrechnet habe, jedem Stochastik-Profi steht frei das zu überprüfen^^)
36 mögliche Zeichen -> 36^4 = 1679616 Möglichkeiten. (klingt erstmal ziemlich viel)
Beim schreiben der ersten Datei kann keine Kollision auftreten.
Bei der 2ten ist die Chance (36^4-1)/(36^4) dass es keine Kollision gibt, usw.
Bei 300 Dateien ist die Chance schon 2,6% dass es mindestens 1x knallt.
Bei 3000 Dateien sieht es schon ziemlich übel aus. (93% Chance auf mindestens eine Kollision).

Daher habe ich mir irgendwann einmal eine Timestamp Funktion gebastelt (die ebenfalls im 36er System funktioniert und 5 Zeichen braucht). Wenn man (sicher) weiß, dass ein Schreibvorgang länger als ca. 10ms dauert kann diese Funktion ohne Zusätze genutzt werden um große Mengen Dateien mit einem Zeitstempel zu nummerieren. Ganz genau (und sicherer) wäre natürlich der 64Bit Timestamp. Alternativ einfach 8 Zufallszeichen im 36er System nutzen, damit kommt man in fast allen Fällen auch klar.

For $i = 0 To 9 Step 1
	ConsoleWrite(WeekTimestamp() & @CRLF)
	Sleep(10)
Next


; ---------- WeekTimestamp ----------
; Start:     00000
; Ende:      ZZZZZ
; Auflösung: ca. 10 Millisekunden
; Periode:   1 Woche
; -----------------------------------
Func WeekTimestamp()
	Local Static $aChr = StringSplit('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', '', 2)
	Local $iTime = Int((((((@WDAY - 1) * 24 + @HOUR) * 60 + @MIN) * 60 + @SEC) * 1000 + @MSEC) / 10.0022863), $sRet = ''
	While $iTime > 0
		$sRet &= $aChr[Mod($iTime, 36)]
		$iTime = Int($iTime / 36)
	WEnd
	Return $sRet
EndFunc


Func RandomText($iLen)
	Local Static $aChr = StringSplit('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', '', 2)
	Local $sRet = ''
	For $i = 1 To $iLen Step 1
		$sRet &= $aChr[Random(0, 35, 1)]
	Next
	Return $sRet
EndFunc

Allerdings ist mir nicht klar was du vorhast. Wenn du die Dateien zufällig benennst kannst du sie doch nicht wieder in der richtigen Reihenfolge ansprechen ?

Ich habe jetzt leider keine so große Datei am start und kann diese Methode nicht ausprobieren.
In der File.au3 gibts die (mit RegEx arbeitende) Funktion _FileCountLines. Die könntest du ebenfalls ausprobieren. Bei der Geschwindigkeit bin ich nicht sicher (die Funktion habe ich noch nie für große Dateien genutzt), aber sie funktioniert ohne GNU.

lg
M

Das mit dem Farbeinstellungen zurücksetzen klappt.
Skins laden bei mir innerhalb weniger Sekunden.

Das mit dem Rand und Win10 bei einigen Programmen problematisch. z.B. ist (nur an einem Computer, an anderen mit Win10 nicht) die Titelleiste von Firefox ebenfalls 4px zu schmal (wobei das Fenster aber den kompletten Schirm nutzt und die leere Fläche mit der üblichen Hintergrundfarbe für Windows Fenster ausfüllt).

Manchmal werden auch Windowseigene Fenster nicht richtig gezeichnet. Wahrscheinlich dauert es noch ne Weile bis Win10 fehlerfrei läuft

Ahoi, habe in Bezug auf das neue DarkTheme (was mir übrigens sehr gut gefällt) einen winzigen Bug gefunden:

Relevante Informationen:
- Windows 10.0-10586, x64, Education
- Monitor: 1440x900 (kleiner Monitor, alle anderen wurden abgeklemmt)
- Dx 11.2
- ISN Studio 1.00 mit Dark Theme

Bug:
Das ISN-Studio nutzt nicht die komplette Bildschirmfläche. Anhand der beiden Screenshots (einer mit Maximiertem Fenster und einer ohne) sieht man, dass entweder Oben, oder Rechts ein einige Pixel breiter Streifen ist der nicht vom Fenster genutzt wird. Das ist vorallem problematisch, wenn man das ISN Studio schließen will und dahinter ein anderes Fenster im Vollbildmodus läuft, dann schließt man ausversehen mit einem klick in die obere rechte Bildschirmecke das Fenster hinter dem ISN-Studio.

Edit: Jetzt hab ich schonwieder nicht den Bugtracker genutzt... beim nächsten mal^^

Edit2: Noch ein kleiner Bug
Ich habe das Projekt erstellt, während ich das Dark Theme genutzt habe. Anschließend habe ich Themes abgeschaltet und das Programm neu gestartet (damit die Änderungen übernommen werden). Offnet man nun das letzte Projekt, so werden 2 mittleren Editorfenster noch in der dunklen Farbe dargestellt (Hier wird sowohl Farbe, als auch Schriftformatierung aus dem Dark Theme genutzt). Die Treefenster (Dateien links und Skriptbaum rechts) haben zwar die korrekte Hintergrundfarbe, aber noch die Weiße Schriftfarbe, sodass man dort nichts lesen kann. (Screenshot3)

lg
M

Bei 10 Mio Zeichen muss man schauen in wiefern sich ein Puffer lohnt.

Methode1: Kein Puffer
Methode2: 256 Zeichen Puffer -> Maximal 8Bit/Durchlauf möglich
Methode3: 256 Zeichen Puffer -> Maximal 8Bit/Durchlauf möglich. Ist langsamer als 2, da Random vergleichsweise Schnell zu BitAnd und BitShift ist.

Bei 10Mio kann man auch einen 65536 Zeichen Puffer nutzen. Damit wären dann 16Bit/Durchlauf drin. Ein Größerer Puffer macht erstmal keinen Sinn, außer man will 100Mio Zufallszahlen berechnen. Das Gilt natürlich nur AutoIt spezifisch, da man hier davon ausgeht, dass die Randomfunktion für 8Bit die gleiche Laufzeit besitzt wie für 16Bit usw. (In anderen Programmiersprachen hat jeder Befehl eine andere Laufzeit und daher liegt der Knackpunkt in ASM z.B. vermutlich woanderst).

#include <WinAPILocale.au3>
Global $tNUMBERFMT = _WinAPI_CreateNumberFormatInfo(0, 0, 3, '', '.', 1) ; <- ist nur für die formatierte Ausgabe
Global $iCount = 1000000 ; Anzahl der Zufallszeichen
SRandom(@MSEC) ; Startwert für Random ändern
HotKeySet('{ESC}', '_Stop') ; zum Abbrechen des Programms
; ----- Variante 1 mit Chr(Random) -----
Global $sText = '', $iLoop = 0, $iDiff = 0
AdlibRegister('_Progress', 500)
_Progress()
Global $iTimer = TimerInit()
For $iLoop = 1 To $iCount
	$sText &= Chr(Random(0, 255, 1))
Next
$iDiff = TimerDiff($iTimer)
AdlibUnRegister()
ToolTip('')
ConsoleWrite('Variante 1 = ' & Round($iDiff / 1000, 3) & ' sek. (' & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen)' & @CRLF)
;~ MsgBox(0, 'Variante 1', Round($iDiff / 1000, 3) & ' sek.' & @CRLF & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen')
; ----- Variante 1 mit Chr(Random) -----
; ----- Variante 2 mit $aChar[Random] -----
Global $sText = '', $iLoop = 0, $iDiff = 0
AdlibRegister('_Progress', 500)
_Progress()
Global $iTimer = TimerInit()
Global $aChar[256]
For $i = 0 To 255
	$aChar[$i] = Chr($i)
Next
For $iLoop = 1 To $iCount
	$sText &= $aChar[Random(0, 255, 1)]
Next
$iDiff = TimerDiff($iTimer)
AdlibUnRegister()
ToolTip('')
ConsoleWrite('Variante 2 = ' & Round($iDiff / 1000, 3) & ' sek. (' & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen)' & @CRLF)
;~ MsgBox(0, 'Variante 2', Round($iDiff / 1000, 3) & ' sek.' & @CRLF & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen')
; ----- Variante 2 mit $aChar[Random] -----
; ----- Variante 3 mit BitShift $aChar[Random] -----
Global $sText = '', $iLoop = 0, $iDiff = 0
AdlibRegister('_Progress', 500)
_Progress()
Global $iTimer = TimerInit()
Global $aChar[256], $iRandom
For $i = 0 To 255
	$aChar[$i] = Chr($i)
Next
For $iLoop = 1 To $iCount Step 4
	$iRandom = Random(0, 2^31-1, 1)
	For $i = 0 To 3
		$sText &= $aChar[BitAND($iRandom, 0xff)]
		$iRandom = BitShift($iRandom, 8)
	Next
Next
$iDiff = TimerDiff($iTimer)
AdlibUnRegister()
ToolTip('')
ConsoleWrite('Variante 3 = ' & Round($iDiff / 1000, 3) & ' sek. (' & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen)' & @CRLF)
;~ MsgBox(0, 'Variante 2', Round($iDiff / 1000, 3) & ' sek.' & @CRLF & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen')
; ----- Variante 3 mit BitShift $aChar[Random] -----
; ----- Variante 4 (wie Variante 2, nur mit je 2 Chr) -----
Global $sText = '', $iLoop = 0, $iDiff = 0
AdlibRegister('_Progress', 500)
_Progress()
Global $iTimer = TimerInit()
Global $aChar[65536], $iRandom
For $i = 0 To 255
	For $ii = 0 To 255
		$aChar[$i * 256 + $ii] = Chr($i) & Chr($ii)
	Next
Next
For $iLoop = 1 To $iCount Step 2
	$sText &= $aChar[Random(0, 65535, 1)]
Next
$iDiff = TimerDiff($iTimer)
AdlibUnRegister()
ToolTip('')
ConsoleWrite('Variante 4 = ' & Round($iDiff / 1000, 3) & ' sek. (' & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen)' & @CRLF)
;~ MsgBox(0, 'Variante 4', Round($iDiff / 1000, 3) & ' sek.' & @CRLF & _WinAPI_GetNumberFormat(0, StringLen($sText), $tNUMBERFMT) & ' Zeichen')
; ----- Variante 4 mit BitShift $aChar[Random] -----
Func _Stop()
	Exit
EndFunc   ;==>_Stop
Func _Progress()
	ToolTip(Int(100 / $iCount * $iLoop) & '%', Default, Default, 'Progress', 1, 1)
EndFunc   ;==>_Progress

lg
M

Das Programm dazu ist wahrscheinlich einfach zu schreiben. Aber es werden folgende 2 Sachen dafür benötigt:

1. Eine Beispieldatei/Email
- Du kannst hier sämtliche Namen und Preise oder was sonst noch alles darin ist abändern, sodass es keine Probleme gibt.
- Du kannst die Mail/Datei Kürzen (es ist nicht sinnvoll 300 Zeilen von Hand zu editieren, 2-3 reichen aus, wenn sie repräsentativ sind)
z.B.

Hallo Herr/Frau kleinemaus
Anbei die Liste. blablabla...


15098134 - Sitzheizung - 55€
23908852 - Kuchenblech - 5€
58247832 - AA-Batterie - 0.5€


Bis zum nächten Mal, ihr Kundenservice.

2. Ein Beispiel Excel-Blatt
- Hier gilt das gleiche für für Punkt 1. Kürzen und die Namen anpassen.
z.B.

lg
M

Da muss ich mich jetzt mal outen. Als Excel-Noob habe ich in Tabellen auch Send Befehle zum befüllen der Zellen und zum Navigieren verwendet (Dabei muss man Excel natürlich geöffnet haben). Mit der Methode kann man aber nur eintragen und nichts auslesen. Das ist also nichts schlimmes, sondern das übliche Vorgehen bei Anfängern (schätze ich mal, zumindest war das auch meine erste Idee ).

lg
M

In Analysis haben wir ab und zu mal Adjungierte Matrizen genutzt, ob das in Informatik oder beim Restklassenkörper irgendetwas bringt wage ich mal zu bezweifeln, aber es ist (sobald Komplexe Zahlen unterstützt werden) sehr einfach zu programmieren.

Ein Klassiker (der auch selten einen praktischen Nutzen hat) ist die Matrixnorm oder allgemeiner eine beliebige p-Norm (und ggf die Spektralnorm).

Theoretisch gibt es unzählige weitere möglichkeiten Matrizen zu nutzen, aber ich glaube das ist nicht Sinn der Sache hier.

lg
M

Auch wenn ich vermute, dass es nicht zielführend ist...

Zur WinAPI gehören wesentlich mehr Teile als nur die Hand voll Funktionen die in der WinAPI.au3 stecken. Die relevanten Operationen mit Speicherstellen finden sich in der Kernel32.dll wieder, der Wrapper dazu liegt in Memory.au3.

Mit den Alloc-Funktionen kannst du dir einen Teil im Ram reservieren und anschließend mit _MemRead und _MemWrite und _MemMoveMemory darin herumwurschteln. Um in fremden Prozessen zu arbeiten muss man erstmal die Erlaubnis einholen (Sedebugprivilege).

Diese inzwischen zehn Jahre alte UDF werde ich nicht verlinken und nicht hochladen, da damit zu 99% Unfug betrieben wird und soetwas möchte ich nicht unterstüzen. Ich frage mich echt wie dieser Müll es immer wieder schafft aufzutauchen. Die UDF ist über zehn jahre alt, unhandlich, und inzwischen vollständig in der Memory.au3 integriert.

Edit: Außerdem glaube ich, dass es mit deinen AutoIt-Kenntnissen unmöglich ist ein Programm zu schreiben was die Software zur Steuerung der Tastatur imitiert und die G-Tasten mit Funktionen verlinkt. Versuche doch stattdessen das AutoIt-Programm OHNE irgendwelche Umwege zu schreiben und es dann einfach mit der Standard Logitech-Software mit der entsprechenden G-Taste zu verlinken.

Also nochmal ganz langsam:
- Schreibe ein Programm das eine MsgBox aufmacht in der HelloWorld steht.
- Nenne das Programm "G05.exe"
- Benutze die Logitechsoftware um das Programm mit der Taste "G5" zu verlinken. Guckst du hier
- Drücke mit viel Liebe und Leidenschaft auf die Taste G5.
- Geht jetzt eine HelloWorld MsgBox auf bist du fertig.
- Mit deinem neu gewonnen Wissen kannst du jedes beliebige Programm in AutoIt schreiben und es auf jede beliebige Taste legen.
- Obacht: Dein Programm muss sich automatisch beenden nachdem sein Job erfüllt ist, sonst hast du irgendwann tausende Programme laufen
- Tipp: Schau dir _Singleton in der AutoIt-Hilfe an um das gleiche Programm nicht mehrfach auszuführen
- Vorteil: Einfach
- Nachteil: (Taste gedrückt -> kurze Wartezeit -> Programmstart) Die Reaktionszeit ist nicht die Bombe, da jedes Mal ein Programm gestartet- und beendet werden muss. (bei SSD gehts schnell, aber bei alten HDDs könnte das nerven)

lg
M

2 Sekunden ? Da kann man noch was rausholen
z.B. via Assoziativem Array incl Hashtable, wo die Labels den Items, und der Wert der Anzahl entspricht. Das müsste dann lineare Laufzeit beim Zusammenfassen ergeben. Aber 2 Sek ist schon passabel, daher werde ich hier nicht weiterbasteln

lg
M