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

Beiträge von AspirinJunkie

  • Bewegungsmelder

    • AspirinJunkie
    • 18. Juli 2013 um 12:50

    Prinzipiell muss man erstmal fragen was man detektieren möchte: Bewegung im gesamten Bild, den Bereich im Bild einer Bewegung oder auch die Bewegungsrichtung.
    Gehen wir mal von der reinen globalen Bewegungserkennung aus dann wäre folgendes ein einfacher aber ausreichender Algorithmus:

    • Es werden immer zwei aufeinander folgende Videoframes (frame1, frame2) betrachtet
    • Zur Rauschverminderung wird z.B. ein Gaußfilter auf beide Bilder angewendet
    • Bildung eines Differenzbildes (Der Grauwert eines Pixels im Differenzbild ist einfach Pix_frame2 - Pix_frame1)
    • Das Differenzbild wird binarisiert: alles was über einem Schwellwert liegt wird 1 - alles was darunter liegt ist 0
    • Zur weiteren Reduzierung des Rauschens wird ein Erosionsfilter drüber laufen gelassen.
    • Alle Pixel welche nun den Wert 1 haben werden gezählt (die Pixel mit potentieller Bewegung)
    • Ist die Anzahl der Pixel über einem festzulegendem Schwellwert wird SMS gesendet.

    AutoIt ist für die Aufgabe allerdings ziemlich ungünstig.
    Ich würde dir für die Aufgabe Python in Verbindung mit der OpenCV-Bibliothek empfehlen.

  • Integralrechner

    • AspirinJunkie
    • 16. Juli 2013 um 23:31
    Zitat von alpines

    Wenn man eine Solve-Funktion hat dann kann man ich die ganze Funktion integrieren und dann die Werte von 1-3 auslesen.
    Das gleiche ist mein Punktsteigung und Ableitung von Funktionen so.

    Vielleicht kannst du ja folgendes gebrauchen:
    Ich hatte vor einiger Zeit mal ein paar Funktionen zur Kurvendiskussion geschrieben welche so mit den Funktionen umgehen wie du es machen willst:

    AutoIt: Kurvendiskussion numerisch
    #include <Array.au3>
    Global Const $FLT_EPSILON = _GET_FLT_EPSILON()
    
    
    ;----------------------------Funktionswerte & Ableitungen-----------------------------
    Func MyFunc(Const $x)
    	Return Sin($x) * Cos($x)
    EndFunc   ;==>MyFunc
    
    
    Global $Fx = MyFunc ; Entweder ein String (z.B: "sin(x)+2") oder eine Funktionsvariable (z.B. MyFunc oder Cos)
    Global $x = 2
    
    
    ConsoleWrite("Funktion = " & (IsFunc($Fx) ? FuncName($Fx) : $Fx) & @CRLF & _
    		"x = " & $x & @CRLF & _
    		"F(" & $x & ") = " & (IsFunc($Fx) ? $Fx($x) : __F($Fx, StringFormat("%.20f", $x))) & @CRLF & _
    		"F'(" & $x & ") = " & _Abl1($Fx, $x) & @CRLF & _
    		"F''(" & $x & ") = " & _Abl2($Fx, $x) & @CRLF & @CRLF)
    ;-------------------------------------------------------------------------------------
    
    
    
    
    ;----------------------------Nullstellensuche-----------------------------------------
    Global $a = -10 ; linke Grenze
    Global $b = 10 ; rechte Grenze
    
    
    $a_Roots = _GetRoots($Fx, $a, $b, 2 ^ (-12))
    _ArrayDisplay($a_Roots, "Nullstellen der Funktion", Default, Default, Default, "x|f(x)|Iterationen")
    ;-------------------------------------------------------------------------------------
    
    
    ;-----------------------------lokale Extrema------------------------------------------
    $a_Extremas = _GetExtremas($Fx, $a, $b, 2 ^ (-12))
    _ArrayDisplay($a_Extremas, "Extremas der Funktion", Default, Default, Default, "x|f(x)|Iterationen|Typ")
    ;-------------------------------------------------------------------------------------
    
    
    
    
    ;----------------------------- Wendepunkte ------------------------------------------
    Func TempFunc(Const $x)
    	Return _Abl2($Fx, $x)
    EndFunc   ;==>TempFunc
    $a_Wendepunkte = _GetRoots(TempFunc, $a, $b, 2 ^ (-12))
    _ArrayDisplay($a_Wendepunkte, "Wendepunkte der Funktion", Default, Default, Default, "x|f(x)|Iterationen")
    ;-------------------------------------------------------------------------------------
    
    
    
    
    
    
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _GetExtremas
    ; Description ...: Findet alle Bereiche eines Intervalls in denen ein Extrema vorkommt
    ;                   Voraussetzung: h < minimalste Abstand 2er Extremas
    ; Syntax.........: _GetExtremas(Const $cb_F, $a, $b, $h)
    ; Parameters.....:         $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                        $a:        linke Suchbereichsgrenze
    ;                        $b:        rechte Suchbereichsgrenze
    ;                        $h:        Schrittweite der Suchintervalle
    ; Return values..: Array: Array[0][0] = Anzahl der Funde
    ;                         Array[$i][0] = x
    ;                         Array[$i][1] = f(x)
    ;                         Array[$i][2] = Benötigte Anzahl an Iterationen
    ;                         Array[$i][3] = Extrematyp ("Min" oder "Max")
    ;                   False: Fehler
    ;                        @error=    1: a>=b
    ; Requirements...: Funktion float _Fx( string F(x), float x )
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _GetExtremas(Const $cb_F, $a, $b, $h)
    	If $a >= $b Then Return SetError(1, 0, False)
    	Local $a_Ret[][4] = [[0]]
    
    
    	Local $x = $a, $y = $a + $h, $z = $a + 2 * $h
    	Local $Fx = IsFunc($cb_F) ? $cb_F($x) : __F($cb_F, StringFormat("%.20f", $x)), $Fy = IsFunc($cb_F) ? $cb_F($y) : __F($cb_F, StringFormat("%.20f", $y)), $Fz = IsFunc($cb_F) ? $cb_F($z) : __F($cb_F, StringFormat("%.20f", $z))
    	Local $fExtr, $dIterations
    
    
    	While $z < $b
    		If $Fy - $Fx > 0 And $Fz < $Fy Then
    			$fExtr = _Lok_Extr($cb_F, $x, $z, "Max")
    			$dIterations = @extended
    			ReDim $a_Ret[UBound($a_Ret) + 1][4]
    			$a_Ret[0][0] = UBound($a_Ret) - 1
    			$a_Ret[$a_Ret[0][0]][0] = $fExtr
    			$a_Ret[$a_Ret[0][0]][1] = IsFunc($cb_F) ? $cb_F($fExtr) : __F($cb_F, StringFormat("%.20f", $fExtr))
    			$a_Ret[$a_Ret[0][0]][2] = $dIterations
    			$a_Ret[$a_Ret[0][0]][3] = "Max"
    		ElseIf $Fy - $Fx < 0 And $Fz > $Fy Then
    			$fExtr = _Lok_Extr($cb_F, $x, $z, "Max")
    			$dIterations = @extended
    			ReDim $a_Ret[UBound($a_Ret) + 1][4]
    			$a_Ret[0][0] = UBound($a_Ret) - 1
    			$a_Ret[$a_Ret[0][0]][0] = $fExtr
    			$a_Ret[$a_Ret[0][0]][1] = IsFunc($cb_F) ? $cb_F($fExtr) : __F($cb_F, StringFormat("%.20f", $fExtr))
    			$a_Ret[$a_Ret[0][0]][2] = $dIterations
    			$a_Ret[$a_Ret[0][0]][3] = "Min"
    		EndIf
    
    
    		$x = $y
    		$y = $z
    		$z += $h
    
    
    		$Fx = $Fy
    		$Fy = $Fz
    		$Fz = IsFunc($cb_F) ? $cb_F($z) : __F($cb_F, StringFormat("%.20f", $z))
    	WEnd
    
    
    	Return $a_Ret
    EndFunc   ;==>_GetExtremas
    
    
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _GetRoots
    ; Description ...: Findet alle Bereiche eines Intervalls in denen eine Nullstelle vorkommt
    ;                   Voraussetzung: h < minimalste Abstand 2er Nullstellen und
    ;                    Nullstelle != Extrema der Funktion
    ; Syntax.........: _GetRoots(Const $cb_F, $a, $b, $h)
    ; Parameters.....:         $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                        $a:        linke Suchbereichsgrenze
    ;                        $b:        rechte Suchbereichsgrenze
    ;                        $h:        Schrittweite der Suchintervalle
    ; Return values..: Array: Array[0][0] = Anzahl der Funde
    ;                         Array[$i][0] = x
    ;                         Array[$i][1] = f(x)
    ;                         Array[$i][2] = Benötigte Anzahl an Iterationen
    ;                        @error=    1: a>=b
    ; Requirements...: Funktion float _Fx( string F(x), float x )
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _GetRoots(Const $cb_F, $a, $b, $h)
    	If $a >= $b Then Return SetError(1, 0, False)
    
    
    	Local $l = $a, $r = $a + $h
    	Local $Fl = IsFunc($cb_F) ? $cb_F($l) : __F($cb_F, StringFormat("%.20f", $l)), $Fr
    	Local $fRoot, $dIterations
    	Local $a_Ret[][3] = [[0]]
    
    
    	While $r < $b
    		$Fr = IsFunc($cb_F) ? $cb_F($r) : __F($cb_F, StringFormat("%.20f", $r))
    
    
    		If $Fr = 0 Then
    			ReDim $a_Ret[UBound($a_Ret) + 1][3]
    			$a_Ret[0][0] = UBound($a_Ret) - 1
    			$a_Ret[$a_Ret[0][0]][0] = $r
    			$a_Ret[$a_Ret[0][0]][1] = $Fr
    			$a_Ret[$a_Ret[0][0]][2] = 0
    		ElseIf ($Fl < 0 And $Fr >= 0) Or ($Fl >= 0 And $Fr < 0) Then
    			$fRoot = _NullstelleNumerisch($cb_F, $l, $r)
    			$dIterations = @extended
    			ReDim $a_Ret[UBound($a_Ret) + 1][3]
    			$a_Ret[0][0] = UBound($a_Ret) - 1
    			$a_Ret[$a_Ret[0][0]][0] = $fRoot
    			$a_Ret[$a_Ret[0][0]][1] = IsFunc($cb_F) ? $cb_F($fRoot) : __F($cb_F, StringFormat("%.20f", $fRoot))
    			$a_Ret[$a_Ret[0][0]][2] = $dIterations
    		EndIf
    
    
    		$Fl = $Fr
    		$l = $r
    		$r += $h
    	WEnd
    
    
    	Return $a_Ret
    EndFunc   ;==>_GetRoots
    
    
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _Lok_Extr
    ; Description ...: Berechnet die lokalen Extrema in einem Intervall numerisch
    ;                   Methode: Eigener Algorithmus zur stetigen Intervallverkleinerung
    ; Syntax.........: _Lok_Extr(Const $cb_F, $Start, $End, $sTyp)
    ; Return values .: X-Wert des lokalen Extremas
    ;                   @Extended = Anzahl Iterationen
    ;                   bei Fehler:     @error     = 1 : $Start >= $End
    ;                                        = 2 : ungültiger Wert für $sTyp
    ; Parameters.....:         $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                        $Start:        linke Suchbereichsgrenze
    ;                        $End:        rechte Suchbereichsgrenze
    ;                        $sTyp:        String "Max" oder "Min"
    ; Requirements ..: Funktion float _Fx( string F(x), float x )
    ;                   Global $FLT_EPSILON = float
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _Lok_Extr(Const $cb_F, $Start, $End, $sTyp)
    	If $Start >= $End Then Return SetError(1, 0, False)
    
    
    	Local $n = 0
    	Local $dx = ($Start - $End) / 3
    	Local $a = $Start, $b = $Start + $dx, $c = $End - $dx, $d = $End
    	Local $Fa = IsFunc($cb_F) ? $cb_F($a) : __F($cb_F, StringFormat("%.20f", $a)), $Fb = IsFunc($cb_F) ? $cb_F($b) : __F($cb_F, StringFormat("%.20f", $b)), $Fc = IsFunc($cb_F) ? $cb_F($c) : __F($cb_F, StringFormat("%.20f", $c)), $Fd = IsFunc($cb_F) ? $cb_F($d) : __F($cb_F, StringFormat("%.20f", $d))
    
    
    	If Not ($sTyp = "Max" Or $sTyp = "Min") Then Return SetError(2, 0, 0)
    
    
    	Switch $sTyp
    		Case "Max"
    			While True
    				$n += 1
    
    
    				If Abs($dx) < $FLT_EPSILON ^ (1 / 1.1) Then ExitLoop
    
    
    				If ($Fb - $Fa >= 0 And $Fc - $Fb >= 0) Or ($Fc - $Fb > 0 And $Fd - $Fc > 0) Then
    					$a = $b
    					$Fa = $Fb
    				ElseIf ($Fc - $Fb < 0 And $Fd - $Fc <= 0) Or ($Fb - $Fa <= 0 And $Fc - $Fb <= 0) Then
    					$d = $c
    					$Fd = $Fc
    				EndIf
    
    
    				$dx = ($d - $a) / 3
    				$b = $a + $dx
    				$c = $d - $dx
    			WEnd
    		Case "Min"
    			While True
    				$n += 1
    				If Abs($dx) < $FLT_EPSILON ^ (1 / 1.1) Then ExitLoop
    
    
    				If ($Fb - $Fa <= 0 And $Fc - $Fb <= 0) Or ($Fc - $Fb < 0 And $Fd - $Fc < 0) Then
    					$a = $b
    					$Fa = $Fb
    				ElseIf ($Fc - $Fb > 0 And $Fd - $Fc >= 0) Or ($Fb - $Fa >= 0 And $Fc - $Fb >= 0) Then
    					$d = $c
    					$Fd = $Fc
    				EndIf
    
    
    				$dx = ($d - $a) / 3
    				$b = $a + $dx
    				$c = $d - $dx
    			WEnd
    	EndSwitch
    
    
    	Return SetExtended($n, ($a + $b) / 2)
    EndFunc   ;==>_Lok_Extr
    
    
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _NullstelleNumerisch
    ; Description ...: Berechnet die Nullstelle in einem Intervall numerisch
    ;                   Methode: Modifiziertes Anderson-Björck-King Verfahren
    ; Syntax.........: _NullstelleNumerisch(Const $cb_F, $a, $b, $eps)
    ; Return values .: X-Wert der Nullstelle
    ;                   @Extended = Anzahl Iterationen
    ; Parameters.....:       $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                        $a:        linke Suchbereichsgrenze
    ;                        $b:        rechte Suchbereichsgrenze
    ;                        $eps:      der Grenzwert ab dem der Funktionswert f(0) als 0 angesehen wird
    ; Requirements ..: Funktion float _Fx( string F(x), float x )
    ;                   Global $FLT_EPSILON = float
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _NullstelleNumerisch(Const $cb_F, $x1, $x2, $eps = $FLT_EPSILON ^ (1 / 1.1))
    	; Bisektion
    	Local $x3 = ($x1 + $x2) / 2
    	Local $f1 = IsFunc($cb_F) ? $cb_F($x1) : __F($cb_F, StringFormat("%.20f", $x1))
    	Local $f2 = IsFunc($cb_F) ? $cb_F($x2) : __F($cb_F, StringFormat("%.20f", $x2))
    	Local $f3 = IsFunc($cb_F) ? $cb_F($x3) : __F($cb_F, StringFormat("%.20f", $x3))
    
    
    	If Abs($f3) < $eps Then Return SetExtended(0, $x3)
    
    
    	Local $s12, $i = 1, $g, $t
    
    
    	Do
    		; Intervallneubestimmung
    		If $f3 < 0 Then
    			$x1 = $x2
    			$f1 = $f2
    		EndIf
    		$x2 = $x3
    		$f2 = $f3
    
    
    		; Sekante berechnen
    		$s12 = ($f1 - $f2) / ($x1 - $x2)
    		$x3 = $x2 - $f2 / $s12
    
    
    		; Funktionswert evaluieren
    		$f3 = IsFunc($cb_F) ? $cb_F($x3) : __F($cb_F, StringFormat("%.20f", $x3))
    		If Abs($f3) < $eps Then Return SetExtended($i, $x3)
    
    
    		; Intervallneubestimmung zweiter Teil
    		If $f3 < 0 Then
    			$x1 = $x2
    			$f1 = $f2
    			$x2 = $x3
    			$f2 = $f3
    		Else
    			$g = 1.0 - ($f3 / $f2)
    			If $g <= 0 Then $g = 0.5
    
    
    			$x2 = $x3
    			$f1 = $g * $f1
    			$f2 = $f3
    		EndIf
    
    
    		If Abs($x2 - $x1) <= $eps Then
    			If Abs($f2) < Abs($f1) Then
    				Return SetExtended($i, $x2)
    			Else
    				Return SetExtended($i, $x1)
    			EndIf
    		EndIf
    
    
    		$i += 1
    	Until False
    EndFunc   ;==>_NullstelleNumerisch
    
    
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _Abl1
    ; Description ...: Berechnet die 1. Ableitung einer Funktion F(x) an der Stelle x
    ;                   Methode: "zentraler Differenzenquotient"
    ; Syntax.........: _Abl1(Const $cb_F, Const $x, Const $FLT_EPSILON = 1E-15)
    ; Return values .: Wert der 1. Ableitung
    ; Parameters.....: $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                  $x:        Wert der Funktionsvariable
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _Abl1(Const $cb_F, Const $x, Const $FLT_EPSILON = 1E-15)
    	Local Const $h = $FLT_EPSILON ^ (1 / 3)
    	Local $2h = $h+$h
    	If IsFunc($cb_F) Then
    		Return ($cb_F($x + $h) - $cb_F($x - $h)) / (2 * $h)
    	Else
    		Return (__F($cb_F, StringFormat("%.20f", $x + $h)) - __F($cb_F, StringFormat("%.20f", $x - $h))) / (2 * $h)
    	EndIf
    
    
    EndFunc   ;==>_Abl1
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _Abl2
    ; Description ...: Berechnet die 2. Ableitung einer Funktion F(x) an der Stelle x
    ;                   Methode: "zweite Differenz"
    ; Syntax.........: _Abl2(Const $cb_F, $x)
    ; Return values .: Wert der 2. Ableitung
    ; Parameters.....:         $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ;                        $x:        Wert der Funktionsvariable
    ; Requirements ..: Funktion float _Fx( string F(x), float x )
    ;                   Global $FLT_EPSILON = float
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _Abl2(Const $cb_F, $x)
    	Local Const $h = $FLT_EPSILON ^ (1 / 3)
    
    
    	If IsFunc($cb_F) Then
    		Return ($cb_F($x + $h) - 2 * $cb_F($x) + $cb_F($x - $h)) / ($h ^ 2)
    	Else
    		Return (__F($cb_F, StringFormat("%.20f", $x + $h)) - 2 * __F($cb_F, StringFormat("%.20f", $x)) + __F($cb_F, StringFormat("%.20f", $x - $h))) / ($h ^ 2)
    	EndIf
    EndFunc   ;==>_Abl2
    
    
    
    
    ; Wrapperfunktion für den Fall, dass die zu integrierende Funktion als String übergeben wird
    Func __F($s_Func, $x)
    	Return Execute(StringReplace(StringReplace(StringReplace($s_Func, "exp", "§"), "x", $x), "§", "exp"))
    EndFunc   ;==>__F
    
    
    ; #FUNCTION#=================================================================================
    ; Name...........: _GET_FLT_EPSILON
    ; Description ...: Berechnet den binären Rundungsfehler und damit die Rechengenauigkeit
    ; Syntax.........: _GET_FLT_EPSILON
    ; Return values .: Epsilon
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _GET_FLT_EPSILON()
    	Local $x = 1
    
    
    	While True
    		$x /= 2
    		If 1 + $x <= 1 Then ExitLoop
    	WEnd
    
    
    	Return $x
    EndFunc   ;==>_GET_FLT_EPSILON
    Alles anzeigen
  • Integralrechner

    • AspirinJunkie
    • 16. Juli 2013 um 23:15

    Schau dir mal in meinem Beispiel an wie ich das mit der Funktion gemeint hatte.
    Wenn du wirklich die Funktion als String haben willst dann ersetze im String per StringReplace "x" mit dem jeweils aktuellen Wert von x.
    Den resultierenden String führst du dann einfach per Execute() aus und hast das Ergebnis.

    Ich hatte das >>hier<< schonmal genauso umgesetzt.

  • Integralrechner

    • AspirinJunkie
    • 16. Juli 2013 um 22:48
    Zitat von alpines

    Hoffentlich gefällts euch, Kritik und Lob erwünscht!

    Ja gefällt mir sehr.
    Das Verfahren wird wirklich so ähnlich wie du es gelöst hast bei der numerischen Integralberechnung verwendet.
    Die Funktion wird in einem Intervall durch eine einfache Fläche (Rechteck, Trapez etc.) approximiert und damit ein Näherungswert für die Fläche berechnet.
    Wenn man das große Intervall in viele kleine unterteilt und das in jedem Intervall macht kann man die Genauigkeit beliebig steigern.

    Zitat von alpines

    Ich weiß das man die ganze Funktion integrieren kann aber allein um die Funktion "12*(x-2)+4" zu trennen bzw. den String zu solven dauert das ein bisschen.


    Du kannst ja stattdessen eine Funktion mit einem Parameter $x definieren und darin einfach AutoIt die Berechnung machen lassen.
    So kannst du ganz flexibel alle möglichen Funktionen implementieren. (Siehe mein folgendes Beispiel).

    Zitat von alpines

    Wenn jemand eine andere Methode kennst das Integral rauszufinden oder einen anderen Lösungsweg weiß bitte her damit!

    Das Prinzip bleibt immer das selbe. Die Funktion durch einfache Flächen ersetzen und aufsummieren.
    Die Verfahren unterscheiden sich dann lediglich darin welche Form genommen wird.
    Ich habe mal die Mittelpunktregel (Rechteck), Sehnentrapezregel, Tangententrapezregel, Simpsonregel und die Gaußquadratur implementiert.
    Bei diesen muss man explizit angeben in wieviel Teilintervalle der Bereich zerlegt wird womit man die Genauigkeit beeinflussen kann.
    Ein Sonderfall ist die Monte-Carlo Integration - hierbei werden zufällig Werte im Intervall berechnet und der Mittelwert berechnet (sieht ziemlich ineffizient aus - ist aber in höherdimensionalen Gleichungen unerlässlich).
    Zusätzlich gibt es noch die Funktion _MathInt_Calc mit welcher man eine zu erreichende Genauigkeit vorgeben kann.

    Diese Funktionen dienen vor allem dazu die verschiedenen Ansätze zu vergleichen.
    Für den produktiven Einsatz habe ich dann noch die Romberg-Integration implementiert, welche sowohl die Möglichkeit einer zu erreichende Genauigkeit besitzt und zusätzlich noch verdammt fix ist.
    Wenn man also in AutoIt integrieren muss - diese Funktion nehmen.
    Ebenfalls enthalten ist eine Funktion zur Berechnung des Kurvenintegrals.

    Integralberechnung
    [autoit]

    ; eine benutzerdefinierte Funktion mit einem Parameter und einer reelen Zahl als Rückgabewert (=1D-Funktion):
    Func MyFunc(Const $x)
    Return Sin($x)
    EndFunc ;==>MyFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; zu integrierende Funktion als Variable - entweder eine Funktionsvariable oder eine String
    Global Const $IntFunction = MyFunc ; Entweder ein String (z.B: $IntFunction="sin(x)+2") oder eine Funktionsvariable (z.B. $IntFunction = MyFunc oder $IntFunction = Cos)

    [/autoit] [autoit][/autoit] [autoit]

    ; Integralgrenzen:
    Global Const $a = 0
    Global Const $b = ACos(-1) ; = Pi

    [/autoit] [autoit][/autoit] [autoit]

    ; zu erreichende Genauigkeit (nur bei Funktionen welche dies ermöglichen)
    Global Const $EPS = 10E-10

    [/autoit] [autoit][/autoit] [autoit]

    Global $n = 10 ; Anzahl an Wiederholungen für die Zeitmessung
    Global $d_Steps = 256 ; Anzahl der Teilintervalle für die Mittelpunkt/Trapez/Gauß/Simpson/Monte-Carlo-Regel
    Global $f_RealValue = 2.0 ; der bekannte wahre Integrationswert (für Genauigkeitsvergleich)

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    #Region Vergleich der verschiedenen Algorithmen bezüglich Genauigkeit und Geschwindigkeit
    ConsoleWrite(StringFormat("\n------------------ Flächenintegrale ------------------\n"))
    ; Die Mittelpunkt/Rechteckregel:
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Rectangle($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Mittelpunktregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Tangententrapez-Regel:
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_TangentTrapezoidal($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Tangententrapezregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Trapezregel:
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Trapezoidal($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Trapezregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Simpson-Regel
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Simpson($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Simpsonregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Gauss-Regel
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Gauss($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Gaußregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Monte-Carlo-Regel (für 1D nicht schön - für höhere Dimensionen hingegen sehr bedeutend)
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_MonteCarlo($IntFunction, $a, $b, $d_Steps)
    Next
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\t\n", "Monte-Carlo", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Romberg-Integration mit einer Funktionsvariablen
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Romberg(MyFunc, $a, $b, $EPS)
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\tn: %4d\n", "RombergIntegration", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), $k))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Romberg-Integration mit einem String als Funktion
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Romberg("Sin(x)", $a, $b, $EPS)
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\tn: %4d\n", "RombergIntegration mit String", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), $k))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Funktion _MathInt_Calc
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_Calc($IntFunction, $a, $b, $EPS)
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\tn: %4d\n", "_MathInt_Calc", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), Log($k) / Log(2)))

    [/autoit] [autoit][/autoit] [autoit]

    ; Die Funktion _MathInt_CalcAdaptive
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_CalcAdaptive($IntFunction, $a, $b, $EPS)
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %18.16f\tn: %4d\n", "_MathInt_CalcAdaptive", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), Log($k) / Log(2)))
    #EndRegion Vergleich der verschiedenen Algorithmen bezüglich Genauigkeit und Geschwindigkeit

    [/autoit] [autoit][/autoit] [autoit]

    #Region Berechnung des Bogenintegrals
    $f_Kurvenlaenge = _MathIntLineIntegral($IntFunction, $a, $b, $EPS)
    ConsoleWrite(StringFormat("\n------------------ Kurvenintegral --------------------\nKurvenlänge von %.2f bis %.2f: %.20f\n\n", $a, $b, $f_Kurvenlaenge))
    #EndRegion Berechnung des Bogenintegrals

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    #Region Funktionen zur Berechnung einer numerischen Integration
    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Romberg
    ; Description ...: Berechnet das bestimmte Integral eindimensionalen Funktion mit
    ; einer festzulegenden relativen Genauigkeit
    ; Syntax.........: _MathInt_Romberg(Const $a, Const $b, Const $EPS = 0.0001)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $EPS - zu erreichender relativer Integrationsfehler
    ; Hinweis: != absoluter Fehler, rel. Fehler = Abs(1-(berechneter Integralwert / wahrer Integralwert)
    ; $kMax - Maximale Anzahl an Halbierungsintervallen
    ; Return values .: Integral in den Grenzen $a-$b, @extended = Anzahl benötigter Iterationen
    ; @error = 1: Maximale Iterationsanzahl erreicht
    ; Remarks .......: Romberg-Integrationsalgorithmus
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Romberg(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $kMax = 30)
    Local $a_R1[$kMax + 1], $a_R2[$kMax + 1]
    Local $h = $b - $a, $n = 1, $sumf, $f

    [/autoit] [autoit][/autoit] [autoit]

    $a_R1[0] = 0.5 * $h * ((IsFunc($cb_F) ? $cb_F($a) : __F($cb_F, StringFormat("%.20f", $a))) + (IsFunc($cb_F) ? $cb_F($b) : __F($cb_F, StringFormat("%.20f", $b)))) ; Erste Approximation

    [/autoit] [autoit][/autoit] [autoit]

    For $k = 1 To $kMax ; Schrittweise halbieren
    $sumf = 0
    For $i = 1 To $n
    $sumf += (IsFunc($cb_F) ? $cb_F($a + ($i - 0.5) * $h) : __F($cb_F, StringFormat("%.20f", $a + ($i - 0.5) * $h)))
    Next
    $a_R2[0] = 0.5 * ($a_R1[0] + $h * $sumf) ; Trapezoid-Formel
    $f = 1e0
    For $j = 1 To $k ; Quadratur-Ordnung erhöhen
    $f *= 4
    $a_R2[$j] = ($f * $a_R2[$j - 1] - $a_R1[$j - 1]) / ($f - 1) ; Neue Approximation
    Next
    If $k > 1 Then ; Check auf Konvergenz
    If (Abs($a_R2[$k] - $a_R1[$k - 1]) <= ($EPS * Abs($a_R2[$k]))) Then ExitLoop
    If (Abs($a_R2[$k]) <= $EPS) And (Abs($a_R2[$k]) <= Abs($a_R2[$k] - $a_R1[$k - 1])) Then ExitLoop
    EndIf
    $h *= 0.5 ; Halbiere Schrittweite
    $n *= 2
    For $j = 0 To $k
    $a_R1[$j] = $a_R2[$j]
    Next
    Next
    If $k >= $kMax Then Return SetError(1, $k, $a_R2[$k - 1])
    Return SetExtended($k, $a_R2[$k])
    EndFunc ;==>_MathInt_Romberg

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Calc
    ; Description ...: Berechnet das bestimmte Integral eindimensionalen Funktion mit
    ; einer festzulegenden Genauigkeit
    ; Syntax.........: _MathInt_Calc(Const $a, Const $b, Const $EPS = 0.0001)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $EPS - zu erreichende Genauigkeit
    ; $nMax - Maximale Iterationsanzahl
    ; Return values .: Integral in den Grenzen $a-$b, @extended = Anzahl benötigter Iterationen
    ; @error = 1: Maximale Iterationsanzahl erreicht
    ; Remarks .......: Genauigkeitsabschätzung über Vergleich von Gauß mit Simpson-Ergebnissen
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Calc(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, $nMax = 8192)
    Local $n = 1, $h, $rf, $g, $S

    [/autoit] [autoit][/autoit] [autoit]

    Do
    $n *= 2
    $h = ($b - $a) / $n
    $g = _MathInt_Gauss($cb_F, $a, $b, $n, $h)
    $S = _MathInt_Simpson($cb_F, $a, $b, $n, $h)
    $rf = Abs($S - $g) / Abs($g)
    If $n >= $nMax Then Return SetError(1, $n, ($g + $S) / 2)
    Until $rf < $EPS
    Return SetError($n >= $nMax, $n, ($g + $S) / 2)
    EndFunc ;==>_MathInt_Calc

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_CalcAdaptive
    ; Description ...: Berechnet das bestimmte Integral eindimensionalen Funktion mit
    ; einer festzulegenden Genauigkeit
    ; Wie Funktion "_MathInt_Calc" aber mit adaptiver Schrittweitenanpassung zur
    ; Verringerung der notwendigen Iterationen
    ; Syntax.........: _MathInt_CalcAdaptive(Const $a, Const $b, Const $EPS = 0.0001, Const $nMax = 8192, Const $maxRec = 64)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $EPS - zu erreichende Genauigkeit
    ; $nMax - Maximale Iterationsanzahl
    ; $maxRec - Maximale Rekursionstiefe
    ; Return values .: Integral in den Grenzen $a-$b, @extended = Anzahl benötigter Iterationen
    ; @error = 1 : Maximale Iterationsanzahl erreicht
    ; @error = 2 : Maximale Rekursionstiefe erreicht
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_CalcAdaptive(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $nMax = 8192, Const $maxRec = 64)
    Local $c = ($a + $b) / 2
    Local $h = $b - $a
    Local $fa = (IsFunc($cb_F) ? $cb_F($a) : __F($cb_F, StringFormat("%.20f", $a))), $fb = (IsFunc($cb_F) ? $cb_F($b) : __F($cb_F, StringFormat("%.20f", $b))), $fc = (IsFunc($cb_F) ? $cb_F($c) : __F($cb_F, StringFormat("%.20f", $c)))

    [/autoit] [autoit][/autoit] [autoit]

    Local $Int = ($h / 6) * ($fa + 4 * $fc + $fb);
    Local $n = 0
    Local $S = __Simp($cb_F, $a, $b, $EPS, $Int, $fa, $fb, $fc, 0, $maxRec, $nMax, $n)
    Return SetError(@error, $n, $S)
    EndFunc ;==>_MathInt_CalcAdaptive

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Rectangle
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Mittelpunkt/Rechteckregel
    ; Syntax.........: _MathInt_Rectangle($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Mittelpunktregel/Rechteckregel
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Rectangle($cb_F, Const $a, Const $b, Const $n, $h = Default)
    Local $f_sum = 0.0
    If $h = Default Then $h = ($b - $a) / $n

    [/autoit] [autoit][/autoit] [autoit]

    For $j = 1 To $n
    $f_sum += (IsFunc($cb_F) ? $cb_F($a + ($j - 0.5) * $h) : __F($cb_F, StringFormat("%.20f", $a + ($j - 0.5) * $h)))
    Next
    Return $f_sum * $h
    EndFunc ;==>_MathInt_Rectangle

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Trapezoidal
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Sehnentrapezformel
    ; Syntax.........: _MathInt_Trapezoidal($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Sehnentrapezformel
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Trapezoidal($cb_F, Const $a, Const $b, Const $n, $h = Default)
    Local $f_sum = 0.0
    If $h = Default Then $h = ($b - $a) / $n

    [/autoit] [autoit][/autoit] [autoit]

    For $j = 1 To $n - 1
    $f_sum += (IsFunc($cb_F) ? $cb_F($a + $j * $h) : __F($cb_F, StringFormat("%.20f", $a + $j * $h)))
    Next
    Return $h * ($f_sum + ((IsFunc($cb_F) ? $cb_F($a) : __F($cb_F, StringFormat("%.20f", $a))) + (IsFunc($cb_F) ? $cb_F($b) : __F($cb_F, StringFormat("%.20f", $b)))) / 2)
    EndFunc ;==>_MathInt_Trapezoidal

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_TangentTrapezoidal
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Tangententrapezformel
    ; Syntax.........: _MathInt_TangentTrapezoidal($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Tangententrapezformel
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_TangentTrapezoidal($cb_F, Const $a, Const $b, Const $n, $h = Default)
    Local $f_sum = 0.0
    If $h = Default Then $h = ($b - $a) / $n

    [/autoit] [autoit][/autoit] [autoit]

    For $j = 1 To $n - 1
    $f_sum += (IsFunc($cb_F) ? $cb_F($a - (0.5 * $h) + $j * $h) : __F($cb_F, StringFormat("%.20f", $a - (0.5 * $h) + $j * $h)))
    Next
    Return $f_sum * $h
    EndFunc ;==>_MathInt_TangentTrapezoidal

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Simpson
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Simpsonregel
    ; Syntax.........: _MathInt_Simpson($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Simpsonregel
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Simpson($cb_F, Const $a, Const $b, Const $n, $h = Default)
    If $h = Default Then $h = ($b - $a) / $n
    Local $tn = _MathInt_Trapezoidal($cb_F, $a, $b, $n, $h)
    Local $mn = _MathInt_Rectangle($cb_F, $a, $b, $n, $h)

    [/autoit] [autoit][/autoit] [autoit]

    Return 1 / 3.0 * ($tn + 2 * $mn)
    EndFunc ;==>_MathInt_Simpson

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_Gauss
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Gaussregel
    ; Syntax.........: _MathInt_Gauss($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Gaußquadratur
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Gauss($cb_F, Const $a, Const $b, Const $n, $h = Default)
    If $h = Default Then $h = ($b - $a) / $n
    Local $xi
    Local Const $f1 = ((Sqrt(3) - 1) / (2 * Sqrt(3))) * $h, $f2 = ((Sqrt(3) + 1) / (2 * Sqrt(3))) * $h
    Local $f_sum = 0.0

    [/autoit] [autoit][/autoit] [autoit]

    For $j = 0 To $n - 1
    $x_a = $a + $j * $h

    [/autoit] [autoit][/autoit] [autoit]

    $x1 = $x_a + $f1
    $x2 = $x_a + $f2

    [/autoit] [autoit][/autoit] [autoit]

    $f_sum += 0.5 * $h * ((IsFunc($cb_F) ? $cb_F($x1) : __F($cb_F, StringFormat("%.20f", $x1))) + (IsFunc($cb_F) ? $cb_F($x1) : __F($cb_F, StringFormat("%.20f", $x2))))
    Next
    Return $f_sum
    EndFunc ;==>_MathInt_Gauss

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_MonteCarlo
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der Carlo
    ; Syntax.........: _MathInt_MonteCarlo($cb_F, Const $a, Const $b, Const $n, $h = Default)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; $h - Manuelle Schrittweite ($n wird dann ignoriert)
    ; Return values .: Integral in den Grenzen $a-$b
    ; Remarks .......: Monte-Carlo-Regel - für 1D gibt es effizientere - aber für höhere Dimensionen sehr wichtig
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_MonteCarlo($cb_F, Const $a, Const $b, Const $n)
    Local $xi
    Local $f_sum = 0.0

    [/autoit] [autoit][/autoit] [autoit]

    For $j = 1 To $n
    $f_sum += (IsFunc($cb_F) ? $cb_F(Random($a, $b)) : __F($cb_F, Random($a, $b)))
    Next
    Return (($b - $a) * $f_sum) / $n
    EndFunc ;==>_MathInt_MonteCarlo

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathIntLineIntegral
    ; Description ...: Berechnet das Linienintegral einer eindimensionalen Funktion
    ; Syntax.........: _MathIntLineIntegral(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $kMax = 30)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $EPS - zu erreichender relativer Integrationsfehler
    ; Hinweis: != absoluter Fehler, rel. Fehler = Abs(1-(berechneter Integralwert / wahrer Integralwert)
    ; $kMax - Maximale Anzahl an Halbierungsintervallen
    ; Return values .: Integral in den Grenzen $a-$b, @extended = Anzahl benötigter Iterationen
    ; @error = 1: Maximale Iterationsanzahl erreicht
    ; Related .......: __FLI(), _MathInt_Romberg(), _Abl1()
    ; Remarks .......: s(f(x))_a^b = int_a^b(sqrt( 1+ f'(x)^2))
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathIntLineIntegral(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $kMax = 30)
    Global $cb_HelpFuncForLineIntegral = $cb_F
    Return _MathInt_Romberg(__FLI, $a, $b, $EPS, $kMax)
    EndFunc ;==>_MathIntLineIntegral

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    #Region Hilfsfunktionen
    ; Wrapperfunktion für den Fall, dass die zu integrierende Funktion als String übergeben wird
    Func __F($s_Func, $x)
    $s_Func = StringReplace($s_Func, "exp", "§")
    $s_Func = StringReplace($s_Func, "x", $x)
    $s_Func = StringReplace($s_Func, "§", "exp")
    Return Execute($s_Func)
    EndFunc ;==>__F

    [/autoit] [autoit][/autoit] [autoit]

    ; help-function for _MathIntLineIntegral
    Func __FLI(Const $x)
    Return Sqrt(1 + _Abl1($cb_HelpFuncForLineIntegral, $x) ^ 2)
    EndFunc ;==>__FLI

    [/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _Abl1
    ; Description ...: Berechnet die 1. Ableitung einer Funktion F(x) an der Stelle x
    ; Methode: "zentraler Differenzenquotient"
    ; Syntax.........: _Abl1(Const $cb_F, Const $x, Const $FLT_EPSILON = 1E-15)
    ; Return values .: Wert der 1. Ableitung
    ; Parameters.....: $cb_F: Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $x: Wert der Funktionsvariable
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _Abl1(Const $cb_F, Const $x, Const $FLT_EPSILON = 1E-15)
    Local Const $h = $FLT_EPSILON ^ (1 / 3)
    If IsFunc($cb_F) Then
    Return ($cb_F($x + $h) - $cb_F($x - $h)) / (2 * $h)
    Else
    Return (__F($cb_F, StringFormat("%.20f", $x + $h)) - __F($cb_F, StringFormat("%.20f", $x - $h))) / (2 * $h)
    EndIf
    EndFunc ;==>_Abl1

    [/autoit] [autoit][/autoit] [autoit]

    ; Hilfsfunktion für CalcIntegralAdaptiv
    Func __Simp(Const $cb_F, Const $a, Const $b, Const $EPS, Const $S, Const $fa, Const $fb, Const $fc, Const $curRec, Const $maxRec, Const $nMax, ByRef $n)
    $n += 1
    Local Const $c = ($a + $b) / 2, $d = ($a + $c) / 2, $e = ($c + $b) / 2
    Local Const $h = $b - $a

    [/autoit] [autoit][/autoit] [autoit]

    Local Const $fd = (IsFunc($cb_F) ? $cb_F($d) : __F($cb_F, StringFormat("%.20f", $d))), $fe = (IsFunc($cb_F) ? $cb_F($e) : __F($cb_F, StringFormat("%.20f", $e)))

    [/autoit] [autoit][/autoit] [autoit]

    Local $f_left = ($h / 12) * ($fa + 4 * $fd + $fc)
    Local $f_right = ($h / 12) * ($fc + 4 * $fe + $fb)
    Local $Int = $f_left + $f_right

    [/autoit] [autoit][/autoit] [autoit]

    If $n >= $nMax Then Return SetError(1, 0, $Int)

    [/autoit] [autoit][/autoit] [autoit]

    If $curRec >= $maxRec Then Return SetError(2, 0, $Int + ($Int - $S) / 15)
    If Abs($Int - $S) <= 15 * $EPS Then Return $Int + ($Int - $S) / 15

    [/autoit] [autoit][/autoit] [autoit]

    Local $EPS2 = $EPS / 2

    [/autoit] [autoit][/autoit] [autoit]

    Local $Int_L = __Simp($cb_F, $a, $c, $EPS2, $f_left, $fa, $fc, $fd, $curRec + 1, $maxRec, $nMax, $n)
    If @error Then Return SetError(@error, 0, $Int_L + __Simp($cb_F, $c, $b, $EPS2, $f_right, $fc, $fb, $fe, $curRec + 1, $maxRec, $nMax, $n))
    Local $Int_R = __Simp($cb_F, $c, $b, $EPS2, $f_right, $fc, $fb, $fe, $curRec + 1, $maxRec, $nMax, $n)
    Return SetError(@error, 0, $Int_L + $Int_R)
    EndFunc ;==>__Simp
    #EndRegion Hilfsfunktionen

    [/autoit] [autoit][/autoit] [autoit]

    #EndRegion Funktionen zur Berechnung einer numerischen Integration

    [/autoit]
  • Fail mit inetRead O.o

    • AspirinJunkie
    • 16. Juli 2013 um 18:22
    Zitat von alpines

    aber der Code ist schneller als InetRead.
    Meine Methode braucht (auf meinem System) nur ~100ms während InetRead knapp ~120-190ms braucht.


    Wie hast du diese Werte ermittelt?
    Weil ich kann diese nicht reproduzieren.
    Bei meinen Messungen ist InetRead etwa doppelt so schnell als deine Variante:

    Messskript
    [autoit]

    Global Const $N = 50

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    $iT = TimerInit()
    For $i = 1 To $N
    $x = BinaryToString(InetRead("http://v1dr333s.nl/test/update.txt", 1))
    Next
    $iT = TimerDiff($iT) / $N
    ConsoleWrite(StringFormat("%20s:\t%6.2f ms\tRückgabe: %6s\n", "Inetread", $iT, $x))

    [/autoit] [autoit][/autoit] [autoit]

    $iT = TimerInit()
    For $i = 1 To $N
    $x = alpinesGet("www.v1dr333s.nl", "/test/update.txt")
    Next
    $iT = TimerDiff($iT) / $N
    ConsoleWrite(StringFormat("%20s:\t%6.2f ms\tRückgabe: %6s\n", "alpinesGet", $iT, $x))

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Func alpinesGet($s_Host, $s_File)
    TCPStartup()

    [/autoit] [autoit][/autoit] [autoit]

    Local $sUpdatePacket = "GET " & $s_File & " HTTP/1.1" & @CRLF & _
    "Host: " & $s_Host & @CRLF & _
    @CRLF

    [/autoit] [autoit][/autoit] [autoit]

    Do
    $hServer = TCPConnect(TCPNameToIP($s_Host), 80)
    Until $hServer <> -1

    [/autoit] [autoit][/autoit] [autoit]

    TCPSend($hServer, $sUpdatePacket)

    [/autoit] [autoit][/autoit] [autoit]

    Do
    $sUpdateHTML = TCPRecv($hServer, 512)
    Until $sUpdateHTML <> ""

    [/autoit] [autoit][/autoit] [autoit]

    $sUpdateVersion = StringTrimLeft($sUpdateHTML, StringInStr($sUpdateHTML, @CRLF, 1, -1) + 1)

    [/autoit] [autoit][/autoit] [autoit]

    TCPCloseSocket($hServer)
    TCPShutdown()
    Return $sUpdateVersion
    EndFunc ;==>alpinesGet

    [/autoit]
  • Fail mit inetRead O.o

    • AspirinJunkie
    • 16. Juli 2013 um 08:15

    InetRead weiß nicht ob du Textdaten oder Binärdaten aus dem Internet runterladen willst.
    Es behandelt alles erst einmal als Binärdaten.
    Deswegen wird dir der Inhalt als Hex-Zahl ausgegeben (die bevorzugte Darstellung für Binärdaten in AutoIt).
    Willst du stattdessen den Inhalt (oder die Ausgabe) als String behandeln muss folglich um das InetRead noch ein BinaryToString().

  • Mit AutoIt PDF über LaTeX erzeugen

    • AspirinJunkie
    • 14. Juli 2013 um 21:28
    Zitat von Acanis

    Dabei wäre es natürlich super, wenn der Nutzer vorher nicht erst LaTeX installieren zu muss. Sonst müsste das über command prompt (kenne ich mich nicht so mit aus) ja auch funktionieren, aus ner .txt eine .pdf zu machen ?!

    Latex macht nix weiter als eine .Textdatei welche Latex-Code enthält zu interpretieren und somit mit diesen Informationen eine PDF-Datei zu erzeugen.
    Man braucht also eine Latex-Distribution (für Windows Tex Live oder Miktex) welche die ganzen benötigten Latex-Dateien enthält (Interpreter, Schriftarten, Pakete, Styles etc.).
    Dann braucht man nichts mehr zu tun als die Interpreter-Exe (pdflatex.exe, xelatex.exe oder lualatex.exe) zu starten und diesem per Kommandozeilenparameter den Pfad zu seiner Tex-Datei anzugeben.

    Zitat von Acanis

    Um die Installation zu sparen gäbe es 2 Möglichkeiten: Es gibt "LaTeX" auch als "reine *.exe", die man so mit versenden kann ODER man nutzt eine Online-Version.


    Es gibt sowohl von Miktex als auch von Tex Live portable Versionen.
    Allerdings immer noch deutlich überdimensionierter als eine einzelne exe-Datei.
    Eine Alternative wäre dann z.B. die Distribution auf ein gemeinsames Netzlaufwerk auszulagern.

  • XYZ Farbraum - Darstellungsproblem

    • AspirinJunkie
    • 8. Juli 2013 um 16:55
    Zitat von Mars

    Um eine Verlustfreie Umrechnung zu erhalten müsste es eine bijektive Abbildung zwischen dem [0,1]³RGB und [0,1]³XYZ Intervall geben


    Mensch jetzt wird aber tief in der Wörterkiste gekramt... ;)

    Ich bin zwar kein Mathematiker würde dir aber beipflichten. Die Umwandlung XYZ-RGB ist nicht bijektiv da die Umkehrfunktion nicht immer wieder die selben Ausgangswerte erzeugt.
    Wenn wir noch weiter in der Wörterkiste kramen können wir noch sagen dass die Abbildung XYZ-RGB surjektiv ist und die Abbildung RGB-XYZ injektiv. ;)

  • XYZ Farbraum - Darstellungsproblem

    • AspirinJunkie
    • 8. Juli 2013 um 10:33

    Der XYZ-Farbraum kann Farben enthalten welche im RGB-Farbraum nicht vorhanden sind. Es gibt also nicht für jeden XYZ-Wert eine Entsprechung im RGB-Raum.
    Es kann bei der Umrechnung durchaus vorkommen, dass für die einzelnen RGB-Komponenten Werte außerhalb des Bereiches 0..255 herauskommen. Das wären dann solche nicht definierten Farben.
    Man muss also diese Fälle noch abfangen in dem man die resultierenden Werte in diesen Wertebereich presst (was natürlich aber mit Informationsverlust einhergeht).

    Z.B. so:

    Spoiler anzeigen
    [autoit]

    #include <GDIPlus.au3>
    #include <Math.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $iSize = 5 ; Größe der Kacheln in Px
    Global Const $iAnz = 125 ; Anzahl der Kacheln in x, y und z Richtung

    [/autoit] [autoit][/autoit] [autoit]

    Global $hGUI, $hSli, $iZ, $hGFX, $hBRU, $hBUF, $hBMP

    [/autoit] [autoit][/autoit] [autoit]

    $hGUI = GUICreate('XYZ Farbraum', $iSize * $iAnz, $iSize * $iAnz + 25)

    [/autoit] [autoit][/autoit] [autoit]

    $hSli = GUICtrlCreateSlider(0, $iAnz * $iSize, $iSize * $iAnz, 25)
    GUICtrlSetLimit($hSli, 1000, 0)

    [/autoit] [autoit][/autoit] [autoit]

    _GDIPlus_Startup()
    $hGFX = _GDIPlus_GraphicsCreateFromHWND($hGUI)
    $hBMP = _GDIPlus_BitmapCreateFromGraphics($iSize * $iAnz, $iSize * $iAnz, $hGFX)
    $hBUF = _GDIPlus_ImageGetGraphicsContext($hBMP)
    $hBRU = _GDIPlus_BrushCreateSolid()

    [/autoit] [autoit][/autoit] [autoit]

    GUIRegisterMsg(0xF, 'WM_PAINT')
    GUISetState(@SW_SHOW)

    [/autoit] [autoit][/autoit] [autoit]

    _ApplyCol(0.9)

    [/autoit] [autoit][/autoit] [autoit]

    While GUIGetMsg() <> -3
    If GUICtrlRead($hSli) <> $iZ Then
    $iZ = GUICtrlRead($hSli)
    _ApplyCol($iZ / 1000)
    EndIf
    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    _GDIPlus_GraphicsDispose($hGFX)
    _GDIPlus_BrushDispose($hBRU)
    _GDIPlus_GraphicsDispose($hBUF)
    _GDIPlus_BitmapDispose($hBMP)
    _GDIPlus_Shutdown()

    [/autoit] [autoit][/autoit] [autoit]

    Func WM_PAINT()
    _GDIPlus_GraphicsDrawImage($hGFX, $hBMP, 0, 0)
    EndFunc ;==>WM_PAINT

    [/autoit] [autoit][/autoit] [autoit]

    Func _ApplyCol($Z = 0)
    Local $t = TimerInit()
    Local $sCol, $iAnzMinus1 = $iAnz - 1, $klX, $klY
    For $x = 0 To $iAnzMinus1 Step 1
    For $y = 0 To $iAnzMinus1 Step 1
    $klX = $x / $iAnzMinus1
    $klY = $y / $iAnzMinus1
    $sCol = _XYZ_to_RGB($klX, $klY, $Z)
    ;~ $sCol = '0xFF' & Hex(Int(Round($klX * 255, 0)),2) & Hex(Int(Round($klY * 255, 0)),2) & Hex(Int(Round($Z * 255, 0)),2)
    DllCall($ghGDIPDll, 'int', 'GdipSetSolidFillColor', 'handle', $hBRU, 'dword', $sCol)
    DllCall($ghGDIPDll, 'int', 'GdipFillRectangleI', 'handle', $hBUF, 'handle', $hBRU, 'int', $x * $iSize, 'int', $y * $iSize, 'int', $iSize, 'int', $iSize)
    Next
    If IsInt($x / 3) Then WM_PAINT()
    Next
    WM_PAINT()
    $t = TimerDiff($t)
    ConsoleWrite('Dauer für ' & $iAnz ^ 2 & ' Kacheln: ' & Round($t / 1000, 2) & 's' & @TAB & ' Zeit pro Kachel: ' & Round($t / $iAnz ^ 2, 2) & 'ms' & @CRLF)
    EndFunc ;==>_ApplyCol

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Func NormalizeTo255($c)
    Return Hex(_Min(255, _Max(0, Int($c * 255))), 2)
    EndFunc ;==>NormalizeTo255

    [/autoit] [autoit][/autoit] [autoit]

    Func _XYZ_to_RGB(Const $iX, Const $iY, Const $iZ)
    Local $iR, $iG, $iB
    $iR = ($iX * 3.2406) + ($iY * - 1.5372) + ($iZ * - 0.4986)
    $iG = ($iX * - 0.9689) + ($iY * 1.8758) + ($iZ * 0.0415)
    $iB = ($iX * 0.0557) + ($iY * - 0.2040) + ($iZ * 1.0570)

    [/autoit] [autoit][/autoit] [autoit]

    If $iR > 0.0031308 Then
    $iR = 1.055 * ($iR ^ (1.0 / 2.4)) - 0.055
    Else
    $iR *= 12.92
    EndIf
    If $iG > 0.0031308 Then
    $iG = 1.055 * ($iG ^ (1.0 / 2.4)) - 0.055
    Else
    $iG *= 12.92
    EndIf
    If $iB > 0.0031308 Then
    $iB = 1.055 * ($iB ^ (1.0 / 2.4)) - 0.055
    Else
    $iB *= 12.92
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    Return '0xFF' & NormalizeTo255($iR) & NormalizeTo255($iG) & NormalizeTo255($iB)
    EndFunc ;==>_XYZ_to_RGB

    [/autoit]

    Die Funktion welche m-obi gepostet hat ist übrigens nicht die Umrechnung von XYZ zu RGB sondern von RGB zu XYZ.

  • SQL-Ergebnis als Variable speichern

    • AspirinJunkie
    • 5. Juli 2013 um 08:43

    In der Hilfe zu _SQLite_FetchData gibt es doch ein schönes Beispiel und da siehst du dass in $hQuery nicht deine benötigten Informationen stehen sondern im Array $aRow.

  • Geschrieben abfragen

    • AspirinJunkie
    • 1. Juli 2013 um 20:23

    Alle Dateierstellungen auf Laufwerk C:

    Spoiler anzeigen
    [autoit]

    #include <WinAPI.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $s_Path = FileGetLongName("C:\") ; hier den zu prüfenden Pfad eintragen
    If Not FileExists($s_Path) Then Exit MsgBox(48, "Fehler", "Pfad " & $s_Path & " existiert nicht!")

    [/autoit] [autoit][/autoit] [autoit]

    Opt("TrayMenuMode", 1)
    Opt("TrayOnEventMode", 1)

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $SHCNE_RENAMEITEM = 0x0001 ; Änderung von Dateinamen
    Global Const $SHCNE_CREATE = 0x0002 ; Erstellung von Dateien
    Global Const $SHCNE_DELETE = 0x0004 ; Löschen von Dateien
    Global Const $SHCNE_MKDIR = 0x0008 ; Erstellung von Ordnern
    Global Const $SHCNE_RMDIR = 0x0010 ; Löschen von Ordnern
    Global Const $SHCNE_UPDATEDIR = 0x1000 ; Änderungen in einem Pfad
    Global Const $SHCNE_UPDATEITEM = 0x2000 ; Änderungen in einer Datei
    Global Const $SHCNE_UPDATEIMAGE = 0x8000
    Global Const $SHCNE_RENAMEFOLDER = 0x20000
    Global Const $SHCNE_ALLEVENTS = 0x7FFFFFFF ; weitere siehe http://msdn.microsoft.com/en-us/library/…8(v=vs.85).aspx

    [/autoit] [autoit][/autoit] [autoit]

    Global $h_Shell32DLL = DllOpen("shell32.dll")

    [/autoit] [autoit][/autoit] [autoit]

    ; Registriert ein FileSystemEvent mit einer AutoIt-Callback-Funktion
    Global $SHRegister = RegisterFSEvent($s_Path, $SHCNE_CREATE, "EvaluateEvents", True)

    [/autoit] [autoit][/autoit] [autoit]

    ; Erstelle ein Tray-Menü fürs Beenden
    OnAutoItExitRegister("Raus")
    TrayCreateItem("Beenden")
    TrayItemSetOnEvent(-1, "Beenden")

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    ; Endlosschleife damit AutoIt die meiste Zeit über pausiert ist (Beenden über das Tray-Icon möglich)
    Do
    Sleep(500)
    Until 0

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    ; Funktion die aufgerufen wird wenn ein Event auftritt:
    Func EvaluateEvents(Const $hWndGUI, Const $MsgID, Const $wParam, Const $lParam)
    Local $h_pidl = DllStructCreate("PTR; PTR", $wParam)
    Local $a_Ret = DllCall($h_Shell32DLL, "BOOLEAN", "SHGetPathFromIDListW", "ptr", DllStructGetData($h_pidl, 1), "wstr", "")
    Local $s_Path = $a_Ret[2]

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Switch $lParam ; Welche Art von Event ist aufgetreten?
    Case $SHCNE_CREATE ; Wenn ein Element nur vom Inhalt her geändert wurde
    MsgBox(0, "Datei erstellt", "Folgender Date wurde erstellt: " & $s_Path)
    EndSwitch
    ; EndIf
    EndFunc ;==>CheckOfNewFiles

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    ; registriert ein FileSystemEvent eines Pfades mit einer Funktion
    Func RegisterFSEvent(Const $s_Path, Const $d_Events, Const $s_CallBackFunc, Const $bRecursive = True)
    Local $h_MyWinMsg = _WinAPI_RegisterWindowMessage("irgendwas")
    Local $h_GUI = GUICreate("")
    GUIRegisterMsg($h_MyWinMsg, $s_CallBackFunc)

    [/autoit] [autoit][/autoit] [autoit]

    Local $h_PIDLIST = DllCall($h_Shell32DLL, "PTR", "ILCreateFromPathW", "WSTR", $s_Path)
    Local $strct_SHChangeNotifyEntry = DllStructCreate("PTR pidl; BOOLEAN fRecursive")
    DllStructSetData($strct_SHChangeNotifyEntry, 1, $h_PIDLIST[0])
    DllStructSetData($strct_SHChangeNotifyEntry, 2, $bRecursive)

    [/autoit] [autoit][/autoit] [autoit]

    Local $SHRegister = DllCall($h_Shell32DLL, "int", "SHChangeNotifyRegister", _
    "HWND", $h_GUI, _
    "INT", 0x0003, _
    "LONG", $d_Events, _
    "UINT", $h_MyWinMsg, _
    "INT", 1, _
    "ptr", DllStructGetPtr($strct_SHChangeNotifyEntry))
    DllCall("ole32.dll", "none", "CoTaskMemFree", "ptr", $h_PIDLIST[0])
    Return $SHRegister
    EndFunc ;==>RegisterFSEvent

    [/autoit] [autoit][/autoit] [autoit]

    Func Beenden()
    Exit
    EndFunc ;==>Beenden

    [/autoit] [autoit][/autoit] [autoit]

    Func Raus()
    DllCall($h_Shell32DLL, "BOOLEAN", "SHChangeNotifyDeregister", "ULONG", $SHRegister[0])
    DllClose($h_Shell32DLL)
    EndFunc ;==>Raus

    [/autoit]
  • Binärdatei schreiben

    • AspirinJunkie
    • 25. Juni 2013 um 10:14

    Anscheinend von der DB.
    Zumindestens die angehangene Textdatei hat am Ende noch einen Zeilenumbruch.
    Die resultierende PDF soll anscheinend dann aber mit einen @LF enden da du ja festgestellt hast das 0A ein LF in ASCII darstellt.

  • Binärdatei schreiben

    • AspirinJunkie
    • 25. Juni 2013 um 09:56

    Der Zeilenumbruch kommt hinter "0A".
    Der soll entfernt werden - nicht "0A".

  • Binärdatei schreiben

    • AspirinJunkie
    • 25. Juni 2013 um 09:39

    An dem String hängt hinten noch ein Zeilenumbruch dran.
    Entferne ich den ist alles wunderbar.
    Versuch also per StringTrimRight (entweder 1 oder 2 Zeichen entfernen) den String vor der Binarisierung entsprechend aufzuarbeiten.

  • Binärdatei schreiben

    • AspirinJunkie
    • 25. Juni 2013 um 09:26

    Passe mal folgendes Skript an und führe es aus:

    [autoit]

    $s_String = ... hier nur die direkte Datenbankabfrage ohne irgendwelche nachträglichen Formatierungen

    [/autoit][autoit][/autoit][autoit]

    ConsoleWrite(IsString($s_String) & @TAB & StringLen($s_String) & @TAB & StringRegExp($s_String, "^0x[[:xdigit:]]+$") & @CRLF)
    FileWrite("Test.txt", $s_String)

    [/autoit]


    Poste danach mal die Konsolenausgabe und lade die resultierende Textdatei hoch.

    Desweiteren erstelle ein Minimalbeispiel was jeder hier sofort ohne Änderungen ausführen kann um den Fehler bei sich selbst nachzuvollziehen.
    Heißt: Minimale SQlite-Datenbank erstellen und ranhängen und ein wirklich minimales Skript welches lediglich den String aus dieser Mini-DB ausliest und binär schreibt.

  • Binärdatei schreiben

    • AspirinJunkie
    • 25. Juni 2013 um 08:46
    Zitat von Torni

    Alle drei Varianten ausprobiert. Der schreibt nicht binär.


    Bei mir schon:

    [autoit]

    $s_CodeAsString = FileRead("Test.txt")
    FileDelete("Test.pdf")
    FileWrite("Test.pdf", Binary($s_CodeAsString))

    [/autoit]

    Hab mir deinen String als Textdatei gespeichert und als Ergebnis bekomme ich die PDF aus dem Anhang.

    Zitat von Torni

    Den 1.Block des String schreibt er binär und macht mit dem zweiten in Text weiter

    • Warum Blockweise?
    • Warum Stringfunktionen (StringRegExp) verwenden, wenn du doch Binärdaten schreiben willst? - ich sehe auch keine einzige Umwandlung der Ergebnisse aus StringRegExp in Binärdaten - es bleibt ein String.
    • Warum FileWriteLine? Wo gibt es denn in Binärdateien Zeilen? FileWriteLine schreibt einen übergebenen String in die Datei und hängt einen Zeilenumbruch dran - was das ganze bei Binärdaten soll solltest du mal überlegen.


    Kurz: Es funktioniert bei mir auch blockweise völlig problemlos:

    Blockweises Schreiben eines Binärstrings
    [autoit]

    Global $s_CodeAsString, $d_Length, $d_BlockSize, $h_File, $b_Block

    [/autoit] [autoit][/autoit] [autoit]

    $s_CodeAsString = FileRead("Test.txt")
    $d_Length = StringLen($s_CodeAsString)
    $d_BlockSize = 100

    [/autoit] [autoit][/autoit] [autoit]

    $h_File = FileOpen("Test.pdf", 16)

    [/autoit] [autoit][/autoit] [autoit]

    For $i = 0 To INt($d_Length / $d_BlockSize)
    $b_Block = Binary(StringMid($s_CodeAsString, $i * $d_Length, $d_BlockSize))
    FileWrite($h_File, $b_Block)
    Next
    FileClose($h_File)

    [/autoit]

    Dateien

    Test.pdf 7,12 kB – 315 Downloads
  • Array Display Limit ?

    • AspirinJunkie
    • 22. Juni 2013 um 09:56
    Zitat von Kleiner

    gibt es beim Array Display eine Obergrenze (Limit) und wenn seit wann?


    Das liegt an der allgemeinen Grenze für die Anzahl der GUI-Controls: >>AutoIt Limits<<
    Hängt also zusätzlich noch davon ab wieviele Controls du ansonsten noch erstellt hast.
    Ich glaube man konnte das aber noch umgehen wenn man statt GUICtrlCreateListViewItem() _GUICtrlListView_AddItem() verwendet dann sind die Listview Items irgendwie keine eigenständigen Controls - musst du mal testen.

  • WinSCP über RunRait aufrufen klappt nicht.

    • AspirinJunkie
    • 21. Juni 2013 um 13:56

    Warum @comspec & " /c" ?
    Du willst doch kein bestimmtes Kommando der cmd-Shell ausführen sondern lediglich direkt ein Programm starten.
    Also versuch es für den Anfang mal so:

    [autoit]

    RunWait('D:\Backups\Backup_DB\winscp\winscp.exe /console /script=ftp-script.txt')

    [/autoit]

    Ein Problem könnte es unter Umständen noch mit dem WorkingDir geben.
    Je nach dem von wo aus man das AutoItskript aufruft ändert sich das Arbeitsverzeichnis.
    Jetzt wäre die Frage in welchen Verzeichnissen WinSCP nach der angegebenen ftp-script.txt sucht.
    Wahrscheinlich erstmal im Arbeitsverzeichnis.
    Wenn dort aber die ftp-script.txt nicht liegt musst du wahrscheinlich entweder den vollen Pfad zu der txt-Datei eintragen, das entsprechende Arbeitsverzeichnis über RunWait mitgeben oder das Arbeitsverzeichnis des AutoIt-Skriptes per FileChangeDir ändern.

  • Parameter- / Variableübergabe an komiliertes AutoIt-Script

    • AspirinJunkie
    • 21. Juni 2013 um 10:27

    Wenn ich das Skript unverändert kompiliere und folgendermaßen aufrufe:

    Code
    Skriptname.exe Test1 Test2


    bekomme ich folgende Ausgabe:

    Code
    Du hast folgende 2 Werte übergeben: 
    
    
    Test1
    
    
    Test2
  • Parameter- / Variableübergabe an komiliertes AutoIt-Script

    • AspirinJunkie
    • 21. Juni 2013 um 09:14

    Siehe: >>Autoit-Hilfe<<

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™