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

  • Merkwürdiger Rechenfehler

    • AspirinJunkie
    • 5. Oktober 2014 um 18:29

    1e9 wird implizit ein Double-Wert.
    Also eine Gleitkommazahl.
    Wird nun ein Integer mit einer Gleitkommazahl multipliziert und addiert wird der Integer implizit in ein Double gecastet.
    Das führt dazu, dass dein Ausdruck

    [autoit]

    1234567890 * 1e9 + 123456789

    [/autoit]

    als Double-Wert zwischengespeichert wird bevor du es dem UInt64 zuweist.
    Heißt aber auch: Nun schlägt der binäre Rundungsfehler zu - 1234567890123456789 ist als Double-Wert nicht darstellbar.

    Schreib daher stattdessen:

    [autoit]

    1234567890 * 10^9 + 123456789

    [/autoit]

    Dann bleibt dein Ausdruck auch ein Integer.
    Allerdings ein Signed Int64.
    Deswegen kannst du, auch wenn in deiner Struktur UINT64 steht, mit einem AutoIt-Ausdruck keine Zahlen größer 9223372036854775807 zuweisen obwohl UINT64 dies ermöglichen würde.

  • Funktion aus Dictionary aufrufen

    • AspirinJunkie
    • 5. Oktober 2014 um 11:03
    Zitat von Andy

    Irgendwie muss man ja gewisse "Defizite" kompensieren...und wenn es über völlig vermurkste syntaktische Unzulänglichkeiten geschieht.


    Welche Defizite meinst du konkret?
    Wie können diese mit der Index/Dot-On-Expression-Syntax kompensiert werden?

  • Deaktivieren von Netzwerkadapter

    • AspirinJunkie
    • 4. Oktober 2014 um 21:33

    Ähnliche Frage zu diesem Thread gab es schonmal hier: >>Klickmich<<
    Versuch erst einmal das was dort geschrieben wurde.

  • Array in Array verändern

    • AspirinJunkie
    • 2. Oktober 2014 um 09:37
    Zitat von teamnoobPDB

    Nun möchte ich aber Werte in dem Array im Array verändern ohne ihn irgendwo zwischenzuspeichern dann zu ändern und wieder in den $myArray zurückzuverfrachten.

    Geht nicht.
    Der Grund: Bei Variablenzuweisungen wird in AutoIt nicht die Referenz, sondern die Werte zugewiesen.
    Es wird also immer eine Kopie erstellt.
    Hier zur Veranschaulichung:

    [autoit]

    Global $aTemp[3] = ["Test1", "Test2", "Test3"]
    $x = $aTemp
    $x[1] = "Test4"
    ConsoleWrite($aTemp[1] & @CRLF)

    [/autoit]


    Du schreibst in deinem Skript folgendes:

    [autoit]

    ConsoleWrite(($myArray[0])[1])

    [/autoit]


    Implizit ist das aber das selbe als würdest du schreiben:

    [autoit]

    $x = $myArray[0]
    ConsoleWrite($x[1])

    [/autoit]

    Es wird also immer im Hintergrund bei dieser Schreibweise eine Kopie des eingebetteten Arrays erzeugt.
    Das sollte man im Hinterkopf behalten, da dies die Performance eines Skriptes ziemlich beeinflussen kann.

  • _DownloadWithProgress

    • AspirinJunkie
    • 25. September 2014 um 10:21

    Besser - aber noch nicht ganz perfekt ;-):
    Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.

    Bevor du aber weiter rumexperimentierst sollte ich erst einmal dazu sagen, dass ich (glücklicher) Nutzer von Mactype bin.
    Das ist ein grandioser alternativer Font-Renderer für Windows.
    Ich teste es später mal in dem ich ihn deaktiviere.
    Könnte ja wahrscheinlich daran liegen auch wenn ich bei anderen Programmen ein deartiges Verhalten noch nie feststellen konnte.

    Dateien

    AutoIt-Download-Tool.png 26,88 kB – 0 Downloads
  • _DownloadWithProgress

    • AspirinJunkie
    • 25. September 2014 um 09:37

    Ok damit ist es weg - aber wie du sagst flackert es.
    Hab hier gerade Windows 7 - werde es auch mal unter Win8 testen.

    Bleiben noch zwei kleine Sachen:

    • Bei 100% erreicht der Balken nicht das Ende:
      Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.
    • Die Größe des "Download abbrechen"-Buttons ist zu klein:
      Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.

    Dateien

    AutoIt-Download-Tool.png 27,43 kB – 0 Downloads AutoIt-Download-Tool_Button.png 27,43 kB – 0 Downloads
  • _DownloadWithProgress

    • AspirinJunkie
    • 25. September 2014 um 08:39

    UEZ
    Bei deiner Version scheint es bei mir Probleme beim Font-Rendering zu geben:
    Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.
    Kennst du vielleicht den Grund bzw. eine Lösung?
    Bei Oscars Variante tritt das Verhalten nicht auf.

    Oscar
    Ein Vorschlag: Wenn man den Download abbricht sollte auch die unvollständig geladene Datei gelöscht werden.
    Weil eine Funktion zum weitermachen des Downloads gibt es ja nicht.

  • _DownloadWithProgress

    • AspirinJunkie
    • 22. September 2014 um 20:09
    Zitat von Oscar

    Ich konnte bei einem Test keine Probleme feststellen.

    Und bei zwei Tests?... ;)
    Schön - dann ist ja alles in Butter - danke dir.

  • _DownloadWithProgress

    • AspirinJunkie
    • 22. September 2014 um 19:52

    Sehr schöne Funktion - werde ich jetzt sicher öfters nutzen
    Eine Frage hätte ich noch (könnte ich auch testen - aber fragen ist einfacher... :P :(
    Wenn man die Funktion aus einer GUI heraus startet - beziehen sich die GUI-Funktionen dann nach dem Aufruf dieser Funktion wieder auf das äußere GUI?
    Falls nicht: Könntest du noch am Ende ein GUISwitch auf die alte GUI einbauen (so wie du es schon mit dem EventMode machst)?

  • Dateipfad per StringRegExpReplace verändern

    • AspirinJunkie
    • 22. September 2014 um 19:26
    Zitat von Andy

    Kanashius, was hast du gemacht, dass in deinem Post der Backslash nicht "gefressen" wird, so wie bei den anderen und u.a. auch dem Quote?


    Man kann durch Verdopplung den Backslash in den doppelten Anführungszeichen escapen.
    Alternativ kann man auch einfache Anführungszeichen verwenden - dort wird Backslash-Anführungszeichen nicht als Sonderfunktion behandelt. (= Verhalten von PHP)

  • intelligentes Kopieren von Ordnerinhalten

    • AspirinJunkie
    • 22. September 2014 um 17:12

    gmmg
    Hast du noch Windows XP?
    Weil ab Vista ist robocopy schon enthalten.

    Bzw. selbst wenn du XP oder Server 2003 hättest - mit dem Windows Ressource-Kit sollte sich Robocopy auch so nachrüsten lassen, ohne dass man es von einem extra Pfad aufrufen muss.

  • Numerik: Integrale einer eindimensionalen Funktion

    • AspirinJunkie
    • 19. September 2014 um 14:32

    Dieser Thread ist für die Freunde der Numerik gedacht.
    Ich habe hier mal verschiedene numerische Integrationsmethoden implementiert und zum Vergleich gegenübergestellt.
    Implementiert sind Die Mittelpunkt-, Trapez-, Tangententrapez-, Simpson-, Gaußregel, die doppelt-exponentielle Methode, die Monte-Carlo-Methode, sowie die Romberg-Integration.
    Zusätzlich noch eine kleine Funktion zur Berechnung eines Kurvenintegrals.
    Um eine gewünschte Integrationsgenauigkeit sicherzustellen gibt es eine Funktion namens _MathInt_IntAccurate welche die Genauigkeit iterativ prüft (außer für die Monte-Carlo-Methode (da versagt der Ansatz) und die Romberg-Integration (da ist die Genauigkeitsschätzung schon drin)).

    Natürlich kann man das ganze auch produktiv einsetzen.
    Für den Fall empfehle ich vor allem die Romberg-Integration - die erreicht die geforderte Genauigkeit verdammt fix.
    Um das ganze auch flexibel zu verwenden, kann man seine zu integrierende Funktion entweder als String (z.B. "sin(x)") oder als AutoIt-Funktion angeben).

    Genug zur Einstimmung - hier das Skript:

    Numerische 1D-Integration mit festgelegter Genauigkeit - Algorithmenvergleich
    [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-5

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

    Global $n = 10 ; Anzahl an Wiederholungen für die Zeitmessung
    Global $d_Steps = 256 ; Anzahl der Teilintervalle für die 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"))

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

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

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

    ; Die doppelt-exponentielle Methode
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_IntAccurate($IntFunction, $a, $b, $EPS, "DoubleExponential")
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %5.2e\tn: %4d\n", "Doppelt-Exponentiell", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), $k))

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

    ; Die Gauss-Regel
    $iT = TimerInit()
    For $i = 1 To $n
    $Int = _MathInt_IntAccurate($IntFunction, $a, $b, $EPS, "Gauss")
    Next
    $k = @extended
    ConsoleWrite(StringFormat("%30s: %5.2f ms\tWert: %20.16f\tEPS: %5.2e\tn: %4d\n", "Gaußregel", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int), $k))

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

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

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

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

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

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

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

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

    [/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: %5.2e\t\n", "Monte-Carlo", TimerDiff($iT) / $n, $Int, Abs($f_RealValue - $Int)))
    #EndRegion Vergleich der verschiedenen Algorithmen bezüglich Genauigkeit und Geschwindigkeit

    [/autoit] [autoit][/autoit] [autoit][/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][/autoit] [autoit]

    #Region Funktionen zur Berechnung einer numerischen Integration
    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_IntAccurate
    ; Description ...: Berechnet das bestimmte Integral eindimensionalen Funktion mit
    ; einer festzulegenden Genauigkeit mit verschiedenen Algorithmen
    ; Syntax.........: _MathInt_IntAccurate(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $s_Method = "DoubleExponential")
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $EPS - zu erreichender Integrationsfehler
    ; $s_Method - Integrationsmethode (Werte: "Rectangle"|"DoubleExponential"|"Trapez"|"TangentTrapezoidal"|"Simpson"|"Gauss")
    ; Return values .: Integral in den Grenzen $a-$b, @extended = Anzahl benötigter Iterationen
    ; @error = 1: Maximale Iterationsanzahl erreicht
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_IntAccurate(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $s_Method = "DoubleExponential")
    Local $s, $s0 = 0, $dx0 = 10e50, $i = 4, $dx
    Do
    Switch $s_Method
    Case "Rectangle"
    $s = _MathInt_Rectangle($cb_F, $a, $b, $i)
    Case "DoubleExponential"
    $s = _MathInt_DoubleExponential($cb_F, $a, $b, $i)
    Case "Trapez"
    $s = _MathInt_Trapezoidal($cb_F, $a, $b, $i)
    Case "TangentTrapezoidal"
    $s = _MathInt_TangentTrapezoidal($cb_F, $a, $b, $i)
    Case "Simpson"
    $s = _MathInt_Simpson($cb_F, $a, $b, $i)
    Case "Gauss"
    $s = _MathInt_Gauss($cb_F, $a, $b, $i)
    Case Else
    Return SetError(1, 0, False)
    EndSwitch
    $dx = Abs($s - $s0)

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

    If $dx = 0 And $i <> 1 Then ExitLoop
    If $i > 2 And $dx0 < $EPS Then ExitLoop
    $dx0 = $dx
    $s0 = $s
    $i *= 2
    If $i > 1048576 Then Return SetError(1, Log($i) / Log(2), $s)
    Until 0
    Return SetExtended(Log($i) / Log(2), $s)
    EndFunc ;==>_MathInt_IntAccurate

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

    ; #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
    ; Related .......: __F()
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_Romberg(Const $cb_F, Const $a, Const $b, Const $EPS = 0.0001, Const $kMax = 15)
    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 = 1.0
    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][/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][/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][/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][/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][/autoit] [autoit]

    ; #FUNCTION#=================================================================================
    ; Name...........: _MathInt_DoubleExponential
    ; Description ...: Berechnet das bestimmte Integral einer eindimensionalen Funktion
    ; mit der doppelt-exponentiellen Methode
    ; Syntax.........: _MathInt_DoubleExponential($cb_F, Const $a, Const $b, Const $n)
    ; Parameters ....: $cb_F - Funktionsvariable oder Funktionsstring einer 1D-Funktion f(x)
    ; $a - Untere Integrationsgrenze
    ; $b - obere Integrationsgrenze
    ; $n - Anzahl der Teilintervalle
    ; Return values .: Integral in den Grenzen $a-$b
    ; Author ........: AspirinJunkie
    ;============================================================================================
    Func _MathInt_DoubleExponential($cb_F, Const $a, Const $b, $n)
    Local Const $PI = ACos(-1)
    Local $f_sum = 0.0, $z, $exz, $hcos, $hsin, $s, $w, $x, $dxdz
    $n /= 2
    Local $h = 5.0 / $n

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

    For $k = -$n To $n
    $z = $h * $k
    $exz = Exp($z)
    $hcos = $exz + 1.0 / $exz
    $hsin = $exz - 1.0 / $exz
    $s = Exp($PI * $hsin)
    $w = $s + 1.0 / $s
    $x = ($b * $s + $a / $s) / $w
    If ($x <> $a And $x <> $b) Then
    $dxdz = 2 * ($b - $a) * $PI * $hcos / ($w * $w)
    $f_sum += $h * (IsFunc($cb_F) ? $cb_F($x) : __F($cb_F, StringFormat("%.20f", $x))) * $dxdz
    EndIf
    Next
    Return $f_sum
    EndFunc ;==>_MathInt_DoubleExponential

    [/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
    #EndRegion Hilfsfunktionen
    #EndRegion Funktionen zur Berechnung einer numerischen Integration

    [/autoit]
  • Error: Variable used without being declared

    • AspirinJunkie
    • 15. September 2014 um 11:24

    Das mit den Zeilennummern hat folgenden Grund:
    Du bindest zusätzliche AutoIt-Funktionen per #include-Befehl ein.
    Dieser ist ein Präprozessor-Befehl welcher vor dem eigentlichen Kompilieren ausgeführt wird.
    In diesem Fall nimmt er einfach die angegeben Datei und trägt deren Inhalt an diese Stelle in dein Skript ein.
    Dadurch verlängert sich dein Skript natürlich entsprechend.
    Dann wird das Skript kompiliert und ausgeführt. Die Zeilennummern bei Fehlern beziehen sich dann auf das vollständige erweiterte Skript.

    Wie nun die fehlerhafte Zeile finden?
    Nun der einfachste Weg ist: Aktuelles AutoIt und aktuelles Scite4Autoit installieren.
    Dann kannst du an den Anfang deines Skriptes folgendes schreiben:

    [autoit]

    #AutoIt3Wrapper_Run_Au3Stripper=y
    #Au3Stripper_Parameters=/mo /SCI=1

    [/autoit]


    Das sorgt dafür, dass wenn du es kompilierst zusätzlich eine neue Datei *_stripped.au3 erstellt wird, welche das Skript mit aufgelösten includes darstellt.
    Dort kannst du dann nach deiner Zeilennummer schauen.

  • _SepThd() ersetzt _StringAddThousandsSep()

    • AspirinJunkie
    • 15. September 2014 um 09:10
    Zitat von minx

    Kommazahlen funktionieren bei mir tadellos (siehe Code, Zeile 1), wie alle anderen Zahlen auch (außer Potenzen schätze ich). Der Unterschied ist der Input als echte Zahl und nicht als String.

    Oscar meinte wohl eher die Unterscheidung von Tausendertrennzeichen und Dezimaltrennzeichen.
    In euren Beispielen wird sowohl für Tausendertrennzeichen als auch Dezimaltrennzeichen das jeweils gleiche verwendet.

    Typografisch korrekt wäre allerdings das Komma als Dezimaltrennzeichen mit dem Punkt als Tausendertrennzeichen für die deutsche Notation und dem Punkt als Dezimaltrennzeichen mit dem Komma als Tausendertrennzeichen für die englische Notation. (Siehe: >>Klickmich<<)

  • RegEx-Pattern in VBA mit anderer "Logik"?

    • AspirinJunkie
    • 14. September 2014 um 13:10

    Ich habe zwar keine Ahnung von VB aber das beschriebene Verhalten sieht für mich nicht wirklich anders aus als das was AutoIt macht.
    Arbeitet man bei StringRegExp mit flag 2 oder 4 wird im Return[0] der globale Match und erst in den folgenden indizes die capture-groupgs (submatches) zurückgegeben.

    Der einzige wirkliche Unterschied den ich sehe ist, dass man dieses Verhalten in AutoIt über die flag einfacher ändern kann.
    Aber vom Prinzip ist das für mich nichts anderes als in VB.

  • Array und StringRegExp Problem

    • AspirinJunkie
    • 10. September 2014 um 14:46

    Kürzer:

    [autoit]

    For $i In StringRegExp(FileRead("sid.txt"), "(\S.*?)\h+(S[\d-]+)", 4)
    MsgBox(0, "", StringFormat("samid: '%s'\nsid: '%s'", $i[1], $i[2]))
    Next

    [/autoit]

    ;)

  • Funktion FileListToArrayWithDate wirft Fehler: Subscript used on non-accessible variable ....

    • AspirinJunkie
    • 9. September 2014 um 14:38

    Tja - mal wieder der Foren"bug" welcher aus allen \" im Quellcode " macht.
    Folgende Änderung sollte helfen:

    Spoiler anzeigen
    [autoit]

    #include <Array.au3>
    #include <Date.au3>

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

    $FileList = FileListToArrayWithDate(@DesktopDir)
    _ArrayDisplay($FileList)

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

    Func FileListToArrayWithDate($sPath, $sFilter = "*", $iFlag = 0)
    Local $hSearch, $sFile, $sFileList, $sDelim = "|", $a_Time, $a_x
    $sPath = StringRegExpReplace($sPath, "[\\/]+\z", "") & '\' ; ensure single trailing backslash
    If Not FileExists($sPath) Then Return SetError(1, 1, "")
    If StringRegExp($sFilter, "[\\/:><\|]|(?s)\A\s*\z") Then Return SetError(2, 2, "")
    If Not ($iFlag = 0 Or $iFlag = 1 Or $iFlag = 2) Then Return SetError(3, 3, "")
    $hSearch = FileFindFirstFile($sPath & $sFilter)
    If @error Then Return SetError(4, 4, "")
    While 1
    $sFile = FileFindNextFile($hSearch)
    If @error Then ExitLoop
    If ($iFlag + @extended = 2) Then ContinueLoop
    $a_Time = FileGetTime($sPath & $sFile)
    $sFileList &= $sFile & ";" & _DateToDayValue($a_Time[0], $a_Time[1], $a_Time[2]) & $sDelim
    WEnd
    FileClose($hSearch)
    If Not $sFileList Then Return SetError(4, 4, "")
    Local $a_Temp = StringSplit(StringTrimRight($sFileList, 1), "|")
    Local $a_Ret[UBound($a_Temp)][2] = [[$a_Temp[0]]]
    For $i = 1 To UBound($a_Temp) - 1
    $a_x = StringSplit($a_Temp[$i], ";", 2)
    $a_Ret[$i][0] = $a_x[0]
    $a_Ret[$i][1] = $a_x[1]
    Next
    _ArraySort($a_Ret, 1, 1, UBound($a_Ret) - 1, 1)
    Return $a_Ret
    EndFunc ;==>FileListToArrayWithDate

    [/autoit]
  • FileListToArray im gesamten Verzeichnisbaum aber nicht rekursiv

    • AspirinJunkie
    • 9. September 2014 um 14:18

    Bei der Gelegenheit habe ich gleich mal die Variante für den neuen Datentyp Map aus den aktuellen Betas umgesetzt:

    Schnelle Datei/Ordner-Auflistung mit Filterfunktion für den Datentyp Map
    [autoit]

    $m_Ret = FLwMap(@TempDir)
    For $i In MapKeys($m_Ret)
    ConsoleWrite($m_Ret[$i] & @CRLF)
    Next

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

    ; #FUNCTION# ======================================================================================
    ; Name ..........: FLwMap()
    ; Description ...: Listet Dateien und/oder Ordner in einem Verzeichnisbaum
    ; Syntax ........: FLwStr($sSD, Const[ $sPat = '', Const[ $iF = 3]])
    ; Parameters ....: $sSD - Suchort (mehrere Suchorte durch | trennen)
    ; Const $sPat - [optional] regulärer Ausdruck für zu findende Datei/Ordnernamen (default:'')
    ; Const $iF - [optional] 1=nur Dateien, 2=nur Ordner, 3=Dateien+Ordner (default:3)
    ; Return values .: Success - Return Map with continous numbers as keys and Paths as values
    ; Failure - Return "" and set @error
    ; Author ........: AspirinJunkie
    ; Remarks .......: Funktionsweise ist iterativ - nicht rekursiv
    ; Example .......: Yes
    ; $m_Ret = FLwMap(@TempDir)
    ; For $i in MapKeys($m_Ret)
    ; ConsoleWrite($m_Ret[$i] & @CRLF)
    ; Next
    ; =================================================================================================
    Func FLwMap($sSD, Const $sPat = '', Const $iF = 3)
    ;by AspirinJunkie
    Local $mSubD[], $x, $y = -1, $mRet[]
    For $i In StringSplit($sSD, '|', 2)
    If StringRight($i, 1) = '\' Then $i = StringTrimRight($i, 1)
    If Not FileExists($i) Then Return SetError(2, 0, "")
    $x = MapAppend($mSubD, $i)
    Next
    Local $FFFF, $FFNF, $sDir
    Local $aD, $hDLL = DllOpen('kernel32.dll')
    If Not ($iF = 3 Or $iF = 1 Or $iF = 2) Then Return SetError(3, 0, "")
    Do
    $y += 1
    If $y > $x Then ExitLoop
    $sDir = $mSubD[$y]
    $FFFF = FileFindFirstFile($sDir & '\*')
    If $FFFF <> -1 Then
    Do
    $FFNF = FileFindNextFile($FFFF)
    If @error Then ExitLoop
    If @extended Then
    If BitAND(StringRegExp($FFNF, $sPat) * 2, $iF) Then MapAppend($mRet, $sDir & '\' & $FFNF)
    If @error Or BitAND(DllCall($hDLL, 'dword', 'GetFileAttributesW', 'wstr', $sDir & '\' & $FFNF)[0], 0x400) Then ContinueLoop
    $x = MapAppend($mSubD, $sDir & '\' & $FFNF)
    ElseIf BitAND(StringRegExp($FFNF, $sPat), $iF) Then
    MapAppend($mRet, $sDir & '\' & $FFNF)
    EndIf
    Until 0
    FileClose($FFFF)
    EndIf
    Until 0
    DllClose($hDLL)
    Return $mRet
    EndFunc ;==>FLwMap

    [/autoit]


    Wer die Betas derzeit testet kann damit noch ein bisschen was an Speed rausholen.

  • FileListToArray im gesamten Verzeichnisbaum aber nicht rekursiv

    • AspirinJunkie
    • 9. September 2014 um 13:06

    Danke nuely.
    Der Grund hierfür ist das Phänomen hier im Forum, dass \" als Escape für das Anführungszeichen betrachtet wird.
    Das führte dazu, dass die Backslashs in den Pfaden fehlten.
    Hab es jetzt in einfache Anführungszeichen gesetzt.

  • SQLite prüfen ob Datensatz existiert

    • AspirinJunkie
    • 8. September 2014 um 21:11

    Jo - das ist durchaus fehlerhaft.
    Keine Ahnung wie ich da auf das "IN" kam... :)

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™