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

  • Halbdynamisches Array - verbessert die Performance von Größenänderungen erheblich

    • AspirinJunkie
    • 11. August 2014 um 13:12

    Ok dann hätte man die Push-Funktion.
    Pop geht dann aber nicht mehr da diese ja keinen Zugriff auf $aCounter in _DynArrayPush() hat.

    Sicherlich geht es so aber es wird dann schon ziemlich unintuitiv. (Man muss sich den Index merken, dieser muss sicher vor Doppelbelegung sein, Löschen mit einer Push-Funktion... ;-))
    Aber ja du hast Recht: prinzipiell geht es.

  • Halbdynamisches Array - verbessert die Performance von Größenänderungen erheblich

    • AspirinJunkie
    • 11. August 2014 um 12:21
    Zitat von BugFix

    Das läßt sich umgehen, mit einer Statischen Variable in deiner Arrayfunktion. Ich würde ein Static Array einbinden und als zusätzlichen Parameter einen Index, damit die Funktion für mehrere Array gleichzeitig genutzt werden kann. Im Static Array am übergebenen Index den Zähler für das jeweilige zu ändernde Array eintragen.

    Was ist die "Arrayfunktion" bei mir?
    _DynArrayPush? Diese wird ja erst aufgerufen wenn das Array schon erstellt habe.
    Und wenn ich das Array dann nicht mehr benötige und lösche? Vielleicht sogar mit einer Funktion _ArrayDelete(). Wie lösche ich dann dessen Eintrag in der statischen Variable?

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 11. August 2014 um 12:17
    Zitat von Marthog

    Doch es geht. Wenn man den Speicher nicht linear auf die benoetige Groesse erhoeht, sonder z.B. immer auf die naechste Zweierpotenz aufrundet hat man zwar minimalen Speicherverlust, reduziert aber die amortisierte Laufzeit beim Wachsen von quadratisch auf linear.

    Ich weiß - siehe >>Halbdynamisches Array<< ;)
    Der Performance-Vorteil besteht dann aber nur beim Hinzufügen ans Ende. Einfügen und Entfernen innerhalb sind weiter die Domäne einer Arraylist.

    Es ist auch keine Verbesserung von Redim, da dessen Funktionalität ja erhalten bleibt und bleiben soll. Verändert wird hingegen das Verhalten einer Funktion wie _ArrayAdd. Redim wird nicht angetastet.

    Zitat von Marthog

    In C++ gibt es eine, die sich deque nennt und reserviert den Speicher in mehreren grossen Bloecken (meistens 4 kb). Die ganze Datenstruktur funktioniert wie ein Array, laesst sich aber wesentlich schneller fuellen.

    Standardisiert ist das bei der Deque meines Wissens nach nicht. Es kann auch vorkommen, dass die Deque als doppelt-verkettete Liste implementiert ist. Ich weiß aber nicht in welcher STL nun welche der beiden Implementierungen genommen wird.

    Edit: Jetzt weiß ich wieder wo ich die Deque als linked-list kenne: Python. Ob in C++ die Deque teilweise auch als linked-list implementiert wird weiß ich nicht.

  • Halbdynamisches Array - verbessert die Performance von Größenänderungen erheblich

    • AspirinJunkie
    • 11. August 2014 um 09:44

    Ausgehend von dieser Diskussion: >>Performanceanalyse der neuen Datenstruktur "Map"<< habe ich mir Gedanken gemacht, wie man die Folgen eines ReDim minimieren kann.

    Arrays verbrauchen in der Regel exakt so viel Speicher, wie Elemente in diesem enthalten sind.
    Da diese Elemente immer direkt hintereinander stehen, führt dies zu Problemen wenn man Elemente hinzufügen möchte.
    Es muss erst ein größerer Speicher reserviert werden, welcher Platz für das neue Array bietet und dann müssen alle Inhalte vom alten in das neue Array kopiert werden.
    Diese Aufgabe übernimmt ReDim. Je größer so ein Array wird umso länger dauert dann jedes ReDim.
    Ein klassisches Array ist also denkbar ungeeignet wenn man Elemente dynamisch hinzufügen möchte.
    Zwar gibt es alternative Datenstrukturen wie ArrayLists. Diese haben zudem den Vorteil ganz fix neue Elemente innerhalb des Arrays einzufügen. Aber der Direktzugriff auf zufällige Elemente ist bei diesen deutlich langsamer.

    Eine Idee die Folgen von andauerndem ReDim zu minimieren ist folgender:
    Wenn ein Element hinzukommt dann wird die Größe des Arrays nicht um 1 erhöht sondern gleich verdoppelt wenn kein Platz mehr im Array vorhanden ist. Damit hat man dann noch Luft für weitere kommende Elemente.
    Auf diesem Weg spart man sich einige ReDim ein. Analog verhält sich das Ganze beim Entfernen von Elementen.

    Folgendes ignorieren - Funktionen wurden zu einer ausgewachsenen UDF ausgebaut: >>DynArray-UDF<<

    Hierzu habe ich mal eine UDF erstellt (liegt im Anhang) welche folgende Funktionen beinhaltet:

    Code
    _DynArrayPush         - neuen Wert ans Ende anhängen
    _DynArrayPop          - letzten Wert zurückgeben und aus dem Array entfernen
    _DynArrayInsert       - einen oder mehrere Werte innerhalb des Arrays einfügen
    _DynArrayDelete       - einen oder mehrere Werte innerhalb des Arrays entfernen
    _DynArraySearch       - Werte in einem unsortierten Array finden
    _DynArrayBinarySearch - Werte in einem sortierten Array finden
    _DynArraySort         - Array sortieren
    _DynArrayMap          - eine beliebige Funktion auf alle Elemente des Arrays anwenden




    Ein Beispiel zur Verwendung wäre folgendes:

    Beispiel zur UDF &quot;DynArray&quot;
    [autoit]

    #include "DynArray.au3"; Neues ArrayGlobal $a_Array[1] = [0]; Dem Array dynamisch Elemente hinzufügenFor $x = 1 To 9 _DynArrayPush($a_Array, "Test " & $x)Next_ArrayDisplay($a_Array, "Das Array"); Einzelne Elemente innerhalb des Arrays einfügen:_DynArrayInsert($a_Array, "Insert 1", 4)_DynArrayInsert($a_Array, "Insert 2", 5); Mehrere Elemente auf einmal einfügen:Local $a_Temp[] = ["Insert 3", "Insert 4", "Insert 5", "Insert 6"]_DynArrayInsert($a_Array, $a_Temp, 6)_ArrayDisplay($a_Array, "Das Array nach _DynArrayInsert"); Element in einem unsortierten Array suchen:MsgBox(0, "_DynArraySearch", 'Wert "Test 5" am Index ' & _DynArraySearch($a_Array, "Test 5") & ' gefunden.'); Array sortieren:_DynArraySort($a_Array)_ArrayDisplay($a_Array, "Das Array nach _DynArraySort"); Element in einem sortierten Array suchen:MsgBox(0, "_DynArrayBinarySearch", 'Wert "Test 5" am Index ' & _DynArrayBinarySearch($a_Array, "Test 5") & ' gefunden.'); Das letzte Element abrufen und aus dem Array entfernen:MsgBox(0,"_DynArrayPop", 'Das letzte Element: "' & _DynArrayPop($a_Array) & '"'); Elemente löschen:_DynArrayDelete($a_Array, 4, 6)_ArrayDisplay($a_Array, "Das Array nach _DynArrayDelete"); Beispiel für ArrayMap$a_Upper = _DynArrayMap($a_Array, StringUpper)_ArrayDisplay($a_Upper, "Das Array nach _DynArrayMap")

    [/autoit]


    Fassen wir mal die Vor-und Nachteile zusammen:

    Vorteile:

    • Deutlich gesteigerte Performance beim Hinzufügen von Elementen.

    Nachteile:

    • Doppelter Speicherverbrauch im Worst-Case
    • Unstetiger Zeitbedarf für jedes Hinzufügen
    • Zwang zur Notation der Elementanzahl im ersten Element

    Was bringt nun aber _DynArrayPush() im Vergleich zu _ArrayAdd() im Endeffekt wirklich?

    Hierzu kann man bei sich einfach mal folgendes Skript ausführen welches den Zeitbedarf beim dynamischen Hinzufügen von 1000 Elementen vergleicht:

    Performancevergleichsskript _DynArrayPush() -- _ArrayAdd()
    [autoit]

    #include "DynArray.au3"Global $N = 1e3$iT = TimerInit()Global $a_Array[1] = [0]For $i = 1 To $N _DynArrayPush($a_Array, "Test " & $i)Next$iT = TimerDiff($iT)ConsoleWrite(StringFormat("% 15s: \t%7.1f ms\n", "_DynArrayPush()", $iT))_ArrayDisplay($a_Array)$iT = TimerInit()Global $a_Array[] = []For $i = 1 To $N _ArrayAdd($a_Array, "Test " & $i)Next$iT = TimerDiff($iT)ConsoleWrite(StringFormat("% 15s: \t%7.1f ms\n", "_ArrayAdd()", $iT))_ArrayDisplay($a_Array)

    [/autoit]


    Meine Ergebnisse hierbei waren folgende:

    Code
    _DynArrayPush(): 	   10.1 ms
        _ArrayAdd(): 	  222.6 ms


    Dieser Zeitvorteil steigt exponentiell mit der Elementanzahl

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 10. August 2014 um 22:22
    Zitat von James

    Außerdem muss der Rückgabewert von DllStructCreate irgendwo (z.B. in einem Array) zwischengespeichert werden, auch wenn er gar nicht verwendet wird. Zum Erstellen eigener Datenstrukturen ist das also nicht optimal.

    Doch das geht schon. Man nimmt die Speicherallokation von Dllstructcreate weg z.B. mit _MemGlobalAlloc(). Hier mal ein kleines unausgereiftes Beispiel wie man in AutoIt eine einfach verkettete Liste erstellen kann:

    Grundprinzip einer einfach verketteten ArrayList in AutoIt
    [autoit]

    #include <Memory.au3>
    Global Const $tag_LinkedList = "wchar value[255];ptr next"

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

    ; leere neue Arraylist erstellen:
    Global $a_List = ArrayList()

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

    ; Elemente hinzufügen
    $a_Act = $a_List
    For $i = 1 To 100
    $a_Act = ArrayListAppend($a_Act, "Test" & $i)
    Next

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

    ; Liste iterieren und Elemente wieder ausgeben
    $a_Act = $a_List ; Anfangselement
    Do
    ConsoleWrite($a_Act.value & @CRLF)
    $a_Act = ArrayListGetNext($a_Act)
    Until @error

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

    #region ArrayList-Funktionen
    ; eine neue Arraylist erzeugen ($value: Wert ansonsten NULL)
    Func ArrayList($value = Default, $pointer = Default)
    Local $t_List = ($pointer = Default) ? DllStructCreate($tag_LinkedList) : DllStructCreate($tag_LinkedList, $pointer)
    $t_List.value = ($value = Default) ? Null : $value
    $t_List.Next = Null
    Return $t_List
    EndFunc ;==>ArrayList

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

    ; gibt das nächste ArrayList-Element des übergebenen Elementes (@error falls letztes Element erreicht)
    Func ArrayListGetNext(ByRef $aArr)
    If $aArr.Next = 0 Then Return SetError(1, 0, $aArr)
    Return DllStructCreate($tag_LinkedList, $aArr.Next)
    EndFunc

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

    ; Fügt ein Element ans Ende der Liste
    Func ArrayListAppend(ByRef $aList, $value)
    If $aList.value = "" Then ; falls erstes Element beschrieben wird
    $aList.value = $value
    Return $aList
    Else
    $aLast = $aList
    Do
    $aLast = ArrayListGetNext($aLast)
    Until @error

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

    Local $hAdress = _MemGlobalLock(_MemGlobalAlloc(DllStructGetSize($aLast)))
    Local $aElement = ArrayList($value, $hAdress) ; Neues Element erzeugen
    $aLast.Next = $hAdress
    EndIf
    Return $aElement
    EndFunc ;==>ArrayListAppend
    #EndRegion

    [/autoit]


    Bei mir ist schon diese unoptimierte Variante beim dynamischen Erstellen einer Liste mit 1000 Elemente mehr als dreimal so schnell wie Array mit ReDim!
    Dafür sind die zufälligen Zugriffe im Vergleich zum Array unterirdisch langsam da die Liste jedesmal von Anfang an durchlaufen werden muss. Komplettes durchiterieren ist daher hingegen etwa gleich schnell (wenn beides nativ vorliegen würde).

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 10. August 2014 um 18:26
    Zitat von James

    Stimmt, aber wenn das wirklich das Ziel ist, wieso muss ich dann fast alle Datenstrukturen aus COM Objekten "importieren?" Mit einer einfach verketteten Liste könnte man zum Beispiel das ReDim Problem relativ einfach lösen, und wenn wir sowas nativ zur Verfügung hätten könnte sich auch jeder die passende Struktur für den jeweiligen Anwendungsfall aussuche

    Hast du den Thread gelesen?
    Mit Map steht (zumindest in der Beta) nun ein nativer AutoIt-Datentyp zur Verfügung welcher sowohl als Key-Value-Struktur als auch als dynamisches Array verwendet werden kann.
    Importieren musst du nichts mehr.

    Zitat von James

    Oder noch besser, wieso nicht gleich C- bzw. Haskell-artige Strukturen?

    Verkettete Listen kannst du auch jetzt schon mit DllStructCreate erzeugen. Einziges Manko ist, dass als Value nicht Variant funktioniert.

    @Bugfix/Mars
    Der "Python-Weg" wäre eine Alternative. Hierbei bekommt jede Klassenmethode als ersten Parameter eine Variable namens "self". Diese enthält einen Verweis auf das Objekt welche die Funktion aufruft. Erst damit werden Funktionen mit den jeweiligen Objekten verknüpft. Bei anderen Sprachen wird implizit das Selbe gemacht. Bei Python wird es hingegen lediglich explizit geschrieben.
    Beim Aufrufen müsste man dann also als ersten Parameter das Objekt mit übergeben.
    Wirklich objektorientiert wird das dann aber auch noch nicht. Vor allem die Möglichkeit Attribute vor Zugriff außerhalb des Objektes zu schützen klappt hier nicht.

  • StringFormat - String links kürzen

    • AspirinJunkie
    • 10. August 2014 um 15:10

    Nein mit Stringformat ist mir kein Weg bekannt.
    Warum nicht StringRight?

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 10. August 2014 um 13:36
    Zitat von Andy

    Imho wäre 99% der User eher damit geholfen, das elend langsame ReDim(men) von Arrays anzupassen bzw. gleich wegzulassen (und wenn man schon dabei ist, eine dynamische Key/Value und Value/Key-Funktion einzubauen),

    Gerade du solltest doch wissen wie Arrays intern im Speicher aussehen und warum ein ReDim eben so lange dauert. Da lässt sich schon prinzipbedingt nicht viel anpassen.
    Und wie willst du auf diese Struktur einfach mal so eine vernünftige Key/Value-Funktionalität draufsetzen ohne ihre Anordnung im Speicher zu verändern?
    Der Datentyp wurde nicht aus den "Fingern gesaugt" sondern war notwendig wenn man ein dynamisches Array haben will.
    So gut wie jede andere Programmiersprache bietet dies auch - und in der Regel sogar noch weit mehr Strukturtypen.

    Es bleibt dabei: Jede Datenstruktur hat Vor-und-Nachteile und deswegen ihren jeweiligen Anwendungsfall für den es geeigneter ist als andere.
    Das ist auch kein Spielzeug für Cracks sondern schlicht Grundlagen der Programmierung.
    Autoit soll Dinge möglichst schnell und einfach bewerkstelligbar (tolles Wort) machen.
    Eine Map hilft da ungemein.
    Ansonsten muss man sich halt eine Sprache suchen welche zum Ziel hat nur die minimalste Funktionalität zu bieten. AutoIt ist diese Sprache aber ganz sicher nicht.

  • Math2 UDF

    • AspirinJunkie
    • 10. August 2014 um 13:22

    Die UDF ist jetzt schon sehr breitgefächert.
    Da stellt sich die Frage ob man die UDF in Themengebiete aufteilt oder eine derart große UDF beibehält.
    Wenn du sie noch erweitern willst wäre mein Vorschlag: Statistische Tests - die hierfür benötigten Grundfunktionen sind ja alle bereits da.

  • IP Adresse bzw. IP Adresse/Netzmaske im Text suchen

    • AspirinJunkie
    • 9. August 2014 um 22:51

    Bin kein Netzerwerkexperte aber meiner Meinung nach macht diese Subnetzmaske wenig Sinn, da dies bedeuten würde, dass in diesem Subnetz keine Adresse liegt.
    Aber wenn es mit rein muss, dann mach in meinem letzten ausführlichen Beispiel hinter die letzte "254" ein "|255".

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 9. August 2014 um 15:00
    Zitat von Andy

    Das könnte man natürlich auch indizieren, WENN es nicht mehrere Ortschaften zur selben Postleitzahl gäbe (Dictionary fällt schon aus! )

    Dictionary schluckt auch ein Array als Value. Es ist also durchaus damit geeignet schnell alle Orte welche zu einer Plz gehören zu ermitteln.

    Ansonsten verstehe ich dein Anliegen schon muss aber sagen: Du versuchst Nachteile von Key-Value-Strukturen gegenüber einer Indizierung aufzuzeigen und machst dies anhand von Beispielen die für Key-Value-Strukturen ungeeignet sind.
    Wenn man beim Plz-Ort Beispiel bleibt: Möchte man den Ort zur Plz haben und nie andersherum dann ist ein Dictionary geeignet. Die Zugriffszeiten sind fix und der Speicherbedarf ist geringer als bei einem extra Index. Will man zusätzlich auch in die andere Richtung suchen ist ein Dictionary hingegen ungeeignet - so einfach ist das. Für den Fall würde ich dann persönlich aber weg von den Autoit-internen Strukturen gehen und auf eine DB wie Sqlite ausweichen (eben weil man da ja ganz einfach einen Index für zu tätigenden Fragestellungen erstellen kann). Vielleicht kannst du ja mal ein reines AutoIt-Beispiel für den Fall Plz-Ort erstellen damit man mal sieht wie man für diese Daten am besten innerhalb von AutoIt einen Index erstellen kann und wie man das dann handhabt.

    Zitat von Andy

    aber wenn man sowieso TEXT hat (darunter fällt imho so gut wie jede Art von Datei ) , dann finde ich es ehrlich gesagt etwas seltsam (wie bspw hier gezeigt) , dass man csv-Dateien in Dictionarys verfrachtet, anstatt die enthaltenen Texte direkt zu bearbeiten/abzugleichen.

    Text enthält eine Information. Die Art wie man diese behandelt richtet sich danach wie diese Informationen strukturiert sind und nicht danach wie der Grunddatentyp der äußeren Struktur ist. Wie immer: Es kommt immer auf den Anwendungsfall an.
    Klar kannst du eine HTML-Datei als String betrachten und verwenden - wird ja auch in der Regel so gemacht. Aber eine Baumstruktur (wie z.B. beim DOM) wäre ebenfalls geeignet sinvoll mit diesen Daten zu arbeiten und bei vielen Fragestellungen die geeignetere Wahl als auf Stringebene zu arbeiten. Bearbeitest du Excel-Dateien etwa auch nur mit Stringfunktionen? Oder sqlite-db-Dateien?

    Zitat von Andy

    Sicher gibt es nicht DEN richtigen Weg, aber man sollte die vorhandenen Möglichkeiten nutzen.

    Dem schließe ich mich uneingeschränkt an. Dieser Gedanke war auch der Grund für diesen kleinen Vergleich hier.

    Zitat von Andy

    da liegen wir doch garnicht weit auseinander

    Liegen wir selten ;)

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 8. August 2014 um 22:49
    Zitat von eukalyptus

    Verglichen hab ich Map, Dictionary und String indem ich jeweil 1000000 Werte (bestehend aus einem String und einer Zahl) hinzugefügt habe
    Sieger ist Map mit etwa 1432ms, dicht gefolgt von String mit 1753ms und Letzter ist, weit abgeschlagen, Dictionary mit 26101ms

    Die Frage wäre was hast du wie hinzugefügt.
    Hast du für die Map String-Keys oder Integer-Keys verwendet? Hast du MapAppend verwendet (was verdammt schnell ist aber den Key selbst wählt und damit den Key-Value-Aspekt killt)?
    Hast du Dictionary mit der .Add-Methode verwendet oder mit dem "="-Operator?
    Folgendes Skript:

    Spoiler anzeigen
    [autoit]

    Global $oDic = ObjCreate("Scripting.Dictionary")
    Global $oHash = ObjCreate("System.Collections.Hashtable")

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

    Global Const $N = 1000000

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

    $iT = TimerInit()
    Global $s_Str = ""
    For $i = 1 To $N
    $s_Str &= "Test" & ";"
    Next
    $a_String = StringSplit(StringTrimRight($s_Str, 1), ";", 2)
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("String:\t%7.1f ms\n", $it))

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

    Global $m_Map[]
    $iT = TimerInit()
    For $i = 1 To $N
    $m_Map[String($i)] = "Teststring"
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("Map:\t%7.1f ms\n", $it))

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

    Global $m_Map2[]
    $iT = TimerInit()
    For $i = 1 To $N
    MapAppend($m_Map2, "Teststring")
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("MapAppend:\t%7.1f ms\n", $it))

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

    $iT = TimerInit()
    For $i = 1 To $N
    $oDic.add($i, "Teststring")
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("Dictionary:\t%7.1f ms\n", $it))

    [/autoit]

    brachte bei mir folgende Ergebnisse:

    Code
    String:	 1038.5 ms
    Map:	161635.7 ms
    MapAppend:	 1218.4 ms
    Dictionary:	67939.7 ms

    Die Umwandlung des Strings in ein Array ist hier übrigens schon mit drin.
    Ich vermute daher mal, dass du das Dictionary mit MapAppend verglichen hast - oder?

    Zitat von Andy

    Wenn es einem wirklich um Geschwindigkeit geht, spart man sich das Stringsplit und greift direkt mit den unschlagbar schnellen Stringfunktionen auf einzelne Elemente zu, Stichwort "durchnummerierte Liste" / "klassisches Array".

    Du meinst wenn ich z.B. dass 423. Element haben will dann nehme ich StringInStr in Verbindung mit StringMid anstatt einem $Array[422]?

    Zitat von Andy

    Der direkte Index (lookup table) ist im Hinblick auf die Zugriffszeit durch nichts zu ersetzen.

    Zugriffszeit bei welchem Szenario? Wenn man die Position (den Index) in der Struktur vorher kennt ist das definitiv richtig. Aber es gibt doch noch mehr Szenarien. Beispielsweise für für Key-Value-Fragestellungen. Dafür sind Dictionaries und Hash-Tables ja da. Dabei wird die Position aus dem Key berechnet. Bei einem durchnummerierten Array müsste man hierfür hingegen manuell durchgehen bis man das entsprechende Element gefunden hat.
    Wenn man hingegen die Position vorher weiß ist ein Array natürlich das beste wo gibt aber es gibt genügend Szenarien wo andere Strukturen um Welten performanter sind. Key-Value ist ein Szenario - ein anderes ist die Fragestellung: Existiert ein Element in der Struktur? Da stinkt eine durchnummerierte Liste einfach nur ab. Zum Thema dynamisch Elemente hinzufügen brauchen wir erst gar kein Wort verlieren.
    Es kommt immer auf den Anwendungsfall an - deswegen ist es ja so schön, dass es für jeden entsprechende Datenstrukturen gibt. Und die sind eben nicht nur aus Gründen der Bequemlichkeit da sondern durchaus wegen ihrer Performance für ihren jeweiligen Anwendungsfall.

    Zitat von Andy

    zweitens werden die Antwortzeiten entsprechend der Verwaltung ansteigen

    Dafür war das Diagramm gedacht: Zu schauen wie die Zugriffszeiten mit der Größe skalieren. Bei einem Array sind diese linear (also für einen Einzelzugriff konstant). Aber auch eine Hash-Table bietet das während Dictionary und Map sich exponential verhalten zu scheinen (vorsichtig ausgedrückt). Das heißt die Antwortzeiten sind sowohl beim Array als auch der Hash-Table konstant.

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 8. August 2014 um 13:05

    ! Aktualisierte Ergebnisse >>Hier<< !

    In den aktuellen Beta-Versionen von AutoIt (v3.3.13.16 Beta) findet sich ein neuer Datenstrukturtyp mitsamt zugehörigen Funktionen.
    Der Datentyp nennt sich Map und ist in erster Linie ein assoziatives Array.
    Also genau das was wir uns bisher über das Dictionary-Objekt extern reingeholt haben.
    Aber nicht nur das - es ist weitaus flexibler. Für die Keys können Integer und/oder Strings verwendet werden. Nimmt man Strings ist das Verhalten wie ein Dictionary.
    Nimmt man Integer - und vor allem in Verbindung mit der Funktion MapAppend() - dann hat man ein Array, das aber dynamisch. Das heißt das Hinzufügen von Elementen geht um Weiten schneller als ein _ArrayAdd.

    Wenn man nun aber keine Key-Value-Struktur benötigt sondern einfach eine dynamische Stringliste (z.B. beim schrittweisen Erzeugen einer Dateiliste in einem Verzeichnis) dann kann man ebenfalls die Map benutzen.
    Die Strings werden als Keys verwendet und ein Leerwert als Value. Anschließend holt man sich ein Array aus den Keys mit der Funktion MapKeys(). Das geht immer noch schneller als mit _ArrayAdd zu arbeiten. Alternativen hierzu wären die selbe Vorgehensweise mit dem Dictionary-Objekt oder ein String &= mit anschließendem StringSplit.

    Das sind jetzt viele Anwendungsmöglichkeiten und auf so eine interne Struktur habe ich schon länger gewartet.
    Also wollte ich jetzt mal herausfinden ob es denn von der Performance her gravierende Differenzen gibt, so dass ich Hinweise habe wann ich was am ehesten einsetzen kann.

    Hierzu habe ich den Zeitbedarf beim Hinzufügen und Auslesen betrachten. Angefangen mit wenigen Elementen habe ich schrittweise die Anzahl der Elemente in der jeweiligen Struktur erhöht um zu sehen wie der Zeitbedarf mit der Elementanzahl korreliert. Hier sind die Ergebnisse für das Hinzufügen:
    Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.
    Dass die Variante einen String mit Trennzeichen zusammensetzen und am Ende per StringSplit in ein Array zu konvertieren die schnellste Variante werden wird habe ich erwartet. Umso mehr hat mich gefreut, dass die Map, in Verbindung mit MapAppend, da ganz gut mithalten kann. Die Keys werden dabei einfach durchnummeriert (wie beim Array) und wir haben damit also nun eine performante ArrayList direkt in AutoIt.
    Es fällt auf, dass die Variante Dictionary-Elemente per .add-Methode hinzuzufügen (Beispiel: $oDic.add("Key", "Value")) langsamer ist, als die Variante per "="-Operator (Beispiel: $oDic("Key") = "Value"). Dies wird wahrscheinlich daran liegen, dass .add erst prüft ob das Element bereits existiert und einen Fehler wirft, während die =-Variante einfach bestehende Werte überschreibt. Ansonsten bewegen sich Map und Dictionary etwa auf dem selben Niveau. _ArrayAdd (=Array + ReDim) habe ich hier nicht mit reingenommen - dieses war schlicht zu langsam.
    Zusammenfassend, kann man sagen. Will man eine Key-Value-Struktur aufbauen machen Map und Dictionary keinen großen Unterschied beim Hinzufügen von Werten. Möchte man einfache Arraystrukturen mit durchnummerieren Index erzeugen hat man nun mit MapAppend eine gute einfache Möglichkeit hinzugewonnen.

    Das Aufbauen der Struktur ist aber erst ein Schuh. Der andere ist: Wie schnell bekomme ich die Daten da wieder raus.
    Prinzipiell kann man erst einmal auch ohne Benchmark sagen: Bei einer einfachen durchnummerierten Liste, bei dem man ein bestimmtes Element von einer bestimmten Stelle haben möchte, ist ein Array schlicht das performanteste. Möchte man aber Werte suchen oder deren Existenz überprüfen sind Map und Dictionary die 1. Wahl. Und Key-Value Beziehungen sollten ja schon per Definition den Dictionaries und Maps vorbehalten sein.
    Die Keys eines Dictionaries/Map kann man sich aber auch als Array zurückgeben. Dann hat man den schnellen Array-Zugriff auf die Keys in einer solchen Liste. Die Frage ist nur - wie groß ist dabei der Aufwand für das Umwandeln in ein Array?
    Hierzu nun die Ergebnisse. Dargestellt ist der jeweilige Zeitbedarf für einen zufälligen Zugriff auf N Elemente.
    Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.
    Dictionary und Map nehmen sich nicht wirklich viel. Es bleibt wohl eher Geschmackssache was man verwendet.
    Ebenso scheint der Zeitbedarf die Keys in ein Array zu wandeln nicht sehr groß zu sein im Vergleich zum eigentlichen Element-Zugriff.

    Jetzt muss man natürlich dazu sagen, dass die Map noch Beta ist und sich noch viel ändern kann.
    Aber als erste Einschätzung soll dies hier erst einmal genügen.

    Dateien

    Plot-1.png 84,12 kB – 0 Downloads Plot-2.png 78,75 kB – 0 Downloads
  • Math2 UDF

    • AspirinJunkie
    • 7. August 2014 um 21:35

    Da ich es wirklich schade finde, dass diese UDF ziemlich untergeht möchte ich mal einen anerkennenden Push-Post absetzen.

    Die UDF ist wirklich der Wahnsinn.
    Ich verneige mich hiermit vor der aufwendigen Arbeit die dir diese UDF sicherlich bereitet hat. :thumbup:

  • _Geo_Diff - Exakte Berechnung der Distanz zweier Punkte auf der Erdoberfläche

    • AspirinJunkie
    • 7. August 2014 um 20:24

    Ja das ist erstmal bisschen verwirrend, aber richtig so.
    Kurz: Die Winkel müssen nicht zusammen 360° ergeben.
    Wenn man sich auf einer Kugel ein Dreieck zeichnet und die Kanten dabei die jeweils kürzesten Verbindungen auf der Kugel sind dann ist die Innenwinkelsumme in diesem Dreieck größer als 180°.
    Die Gesetzmäßigkeiten der planaren Geometrie gelten nicht mehr vollständig.

    Zitat von Trubadour

    Oder ist der WGS84 Geoid so kartoffelig?

    Nein nein es ist ein ganz glattes normales Rotationsellipsoid.
    Kartoffelig ist erst das Geoid.

  • _Geo_Diff - Exakte Berechnung der Distanz zweier Punkte auf der Erdoberfläche

    • AspirinJunkie
    • 7. August 2014 um 16:56
    Zitat von minx

    Da habe ich genau das Gegenteil gelernt und damit auch in Prüfungen gerechnet

    Na dann: Glück gehabt. Wenn du nicht gerade mal derartige Prüfungen schreibst, kannst du es ja von nun an richtig herum machen.

    Zitat von minx

    Das ist sicher richtig, aber diese Näherung reicht völlig aus, wenn man sie z.B. mit der geläufigen AGPS Triangulation vergleicht.

    Das wollte ich Dir hiermit ja zum Ausdruck bringen. Wenn deine Koordinaten aus GPS-Messungen stammen müsstest du auch mit dem WGS84-Ellipsoid rechnen anstatt einem beliebigen.
    Für das Beispiel hier hat man schon allein dadurch einen Fehler von 3m der nicht sein müsste.
    Herkömmliche GPS-Messungen sind außerdem deutlich genauer als 50m und eine höhere Rechengenauigkeit für die Distanz daher auch hierbei durchaus wünschenswert.

  • _Geo_Diff - Exakte Berechnung der Distanz zweier Punkte auf der Erdoberfläche

    • AspirinJunkie
    • 7. August 2014 um 14:21

    Interessante Lösung.
    Wo stammt dieser Näherungsalgorithmus her und vor allem die Angabe, dass es immer im Bereich ± 0.05 km liegt?
    Für dein Beispiel betrug die Differenz zur exakten Lösung auf dem angegeben Ellipsoid übrigens 6m was ja im Bereich liegt.

    Vielleicht sollte man aber dazusagen: Bei Koordinatenberechnungen auf dem Ellipsoid müssen die angegebenen Koordinaten in einem Bezugssytem ermittelt wurden sein welchem das verwendete Ellipsoid zu Grunde liegt. Sonst sind die ermittelten Werte verfälscht. In Wikipedia z.B. sind die Angaben meist auf WGS84 bezogen (Referenzsystem für GPS-Koordinaten), also muss man auch dessen Werte für die Halbachse und Abplattung verwenden wenn man mit deren Koordinaten rechnen möchte.

    Theoretisch kann man auf dem Ellipsoid bis zu jeder beliebigen Genauigkeit rechnen. Da es sich hier aber um elliptische Integrale handelt welche ein Randwertproblem darstellen, ist die Berechnung ziemlich tricky und nur iterativ zu lösen.
    Hier mal eine Version welche auf etwa 1nm genau rechnet:

    Strecke zweier Punkte auf einem Rotationsellipsoid mit hoher Genauigkeit
    [autoit]

    #Region Hilfsgrößen und Strukturdefinitionen
    Global Const $PI = ACos(-1)
    Global Const $TAG_GEOCOORD = "double B;double L" ; Koordinatenangabe in Dezimalwinkeln (B=Breite/Latitude, L=Länge/Longitude)
    Global Const $TAG_GEOCOORD_HOUR = "int bD;int bM;double bS;int lD;int lM;double lS" ; Koordinateenangabe der Form: Winkel:Minute:Sekunde (b=Breite/Latitude, l=Länge/Longitude, D=Degrees, M=Minuten, S=Sekunden)
    #EndRegion Hilfsgrößen und Strukturdefinitionen

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

    #Region Eingabedaten
    ; Paris Observatory
    $geoParis = 'E-2-20-14-N-48-50-11'
    ConsoleWrite("Paris: " & @TAB & _Coord_PrintHour(_Coords_Degree2Hour(_Coords_GeoData2Degrees($geoParis))) & @CRLF)
    ; US Naval Observatory
    $geoUSA = 'W-77-3-55.5-N-38-55-17'
    ConsoleWrite("USA: " & @TAB & _Coord_PrintHour(_Coords_Degree2Hour(_Coords_GeoData2Degrees($geoUSA))) & @CRLF)
    #EndRegion Eingabedaten

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

    ; Berechne die Distanz der beiden Punkte auf dem Ellipsoid
    Global $a_Ret = _Ellipsoid_DistanceOf2Points(_Coords_GeoData2Degrees($geoParis), _Coords_GeoData2Degrees($geoUSA), 6378137, 1 / 298.257223563)
    ConsoleWrite(StringFormat("Strecke: %15.9f m\n", $a_Ret[0]))
    ConsoleWrite(StringFormat("Azimut im Punkt 1: %15.9f°\n", $a_Ret[1] * 180 / $PI))
    ConsoleWrite(StringFormat("Azimut im Punkt 2: %15.9f°\n", $a_Ret[2] * 180 / $PI))

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

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _Ellipsoid_DistanceOf2Points()
    ; Description ...: Berechnet die Entfernung zweier Punkte auf einem beliebigen Rotationsellipsoid
    ; Syntax ........: _Ellipsoid_DistanceOf2Points($P1, $P2[, $a = 6378137[, $f = 1 / 298.257222101]])
    ; Parameters ....: $P1 - Koordinaten von P1 als DezimalGrad-Angaben in der Struktur $TAG_GEOCOORD
    ; $P2 - Koordinaten von P2 als DezimalGrad-Angaben in der Struktur $TAG_GEOCOORD
    ; $a - [optional] Große Halbachse des Rotationsellipsoiden (weitere: http://de.wikipedia.org/wiki/Referenze…erenzellipsoide) (default:6378137)
    ; $f - [optional] Abplattungsfaktor des Rotationsellipsoiden (weitere: http://de.wikipedia.org/wiki/Referenze…erenzellipsoide) (default:1 / 298.257222101)
    ; $EPS- zu erreichende Genauigkeit
    ; Return values .: Success Array: [Strecke, Azimut1, Azimut2]
    ; Failure
    ; Author ........: AspirinJunkie
    ; Related .......: __Gn, __Mn, __Simp, __Sn, __Tn, CalcIntegral, CalcIntegralAdaptiv, f, IntMonteCarlo, Sign
    ; Remarks .......: Lösungsalgorithmus entsprechend H. Schmidt, RWTH Aachen 2000
    ; =================================================================================================
    Func _Ellipsoid_DistanceOf2Points($P1, $P2, $a = 6378137, $f = 1 / 298.257223563, Const $EPS = 1e-15)
    Local $s_Funktion ; Variable welche die zu integrierende Funktion f(x) als String enthält
    Local $b = $a - $f * $a ; kleine Halbachse des Ellipsoides
    Local $e2 = 1 - (($b / $a) ^ 2) ; Quadrat der 1. numerischen Exzentrizität

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

    Local $B1 = $P1.B * $PI / 180 ; Breite von Punkt 1 in Radiant
    Local $B2 = $P2.B * $PI / 180 ; Breite von Punkt 2 in Radiant
    Local $L1 = $P1.L * $PI / 180 ; Länge von Punkt 1 in Radiant
    Local $L2 = $P2.L * $PI / 180 ; Länge von Punkt 2 in Radiant

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

    ; reduzierte Breiten beta1 und beta2:
    Local $beta1 = (Abs($B1 - ($PI / 2)) < 1E-5) ? $B1 : ATan(Sqrt(1 - $e2) * Tan($B1)) ; zusätzlicher Check ob eine Breite dem Pol entspricht
    Local $beta2 = (Abs($B2 - ($PI / 2)) < 1E-5) ? $B2 : ATan(Sqrt(1 - $e2) * Tan($B2))

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

    ; Ausgangswerte für Restabweichung und Langendifferenz
    Local $deltaL
    Local $deltaLsoll = $L2 - $L1
    Local $deltaLs = $L2 - $L1
    Local $dL = $deltaLsoll
    Local $dL1, $dL2 ; Längendifferenzen für beide Fälle

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

    ; Vorzeichen der Längendifferenz
    Local $y = Sign($deltaLsoll)

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

    ; iterative Berechnung der Intergrationsgrenzen
    Local $tanBetaMax ; tangens der maximalen Breite der geodätischen Linie
    Local $h2, $h ; Clairaut-Konstante
    Local $w1, $w2, $wu, $wo ; Integrationsgrenzen
    Local $deltaL1, $deltaL2 ; Lösung für Fall 1 und Fall 2
    Local $FALL ; Angabe welcher Fall vorherrscht
    Local $d_ItMax = 50, $it = 0 ; Maximale Iterationsanzahl (um Endlosschleifen zu vermeiden)
    Do
    ; tangens der maximalen Breite der geodätischen Linie
    $tanBetaMax = Sqrt(1 - $e2) * (Sqrt(Tan($B1) * Tan($B1) + Tan($B2) * Tan($B2) - 2 * Tan($B1) * Tan($B2) * Cos($deltaLs)) / Sin($deltaLs))

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

    ; Clairaut-Konstante
    $h2 = 1 / (1 + $tanBetaMax * $tanBetaMax)

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

    ; Integrationsgrenzen
    $w1 = ASin(Tan($beta1) / $tanBetaMax)
    $w2 = ASin(Tan($beta2) / $tanBetaMax)

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

    If Abs($dL) < $EPS Or $it >= $d_ItMax Then ExitLoop ; Integrationsgrenzen hinreichend genau bestimmt

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

    $wu = (Abs($w1) < Abs($w2) ? Abs($w1) : Abs($w2)) ; = Min(w1,w2)
    $wo = (Abs($w1) > Abs($w2) ? Abs($w1) : Abs($w2)) ; = Max(w1,w2)

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

    ; Berechnung von wu und wo für Fall 1 (es gibt zwei mögliche Lösungen - daher beide berechnen und mit $deltaLsoll vergleichen)
    $FALL = 1
    $s_Funktion = "sqrt( 1-(" & $e2 * $h2 & " / (" & $h2 & " + " & (1 - $h2) & " * sin(x)*sin(x))))"

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

    $deltaL1 = $y * Abs(_MathInt_Romberg($s_Funktion, $wu, $wo, $EPS)) ; Integralberechnung bis auf 1e-14 Genauigkeit
    ; Addition der Abschnitte symmetrisch zum Äquator
    If ($w1 * $w2) < 0 Then $deltaL1 += $y * 2 * _MathInt_Romberg($s_Funktion, 0, $wu, $EPS)

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

    ; Längendifferenz $dL und Restabweichung DL für Fall I
    $deltaL = $deltaL1
    $dL1 = $deltaLsoll - $deltaL1
    $dL = $dL1

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

    ; Addition der Abschnitte symmetrisch zu Bmax für Fall II
    $deltaL2 = $deltaL1 + $y * 2 * _MathInt_Romberg($s_Funktion, $wo, 0.5 * $PI, $EPS)

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

    ; Längendifferenz $dL und Restabweichung DL für Fall II
    $dL2 = $deltaLsoll - $deltaL2

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

    ; Entscheidung für Fall 1 oder 2
    If (Abs($dL2) < Abs($dL1)) Then ; Fall 2 ist vorhanden - daher dessen Ergebnisse übernehmen
    $FALL = 2
    $deltaL = $deltaL2
    $dL = $dL2
    EndIf

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

    ; Korrektur von $deltaLs zur Berechnung von tanBmax
    $deltaLs = $deltaLs + (1 + ($dL / ($FALL * $deltaL))) * $dL
    $it += 1 ; Iterationszähler inkrementieren
    Until 0
    ; Azimutberechnung
    ; Vorzeichen der Breitendifferenz
    Local $x = Sign($w2 - $w1)
    If $FALL = 2 Then $x = Sign(Sign($B1 + $B2) * $PI - $w2 - $w1)

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

    ; Azimute A1 und A2
    Local $A1 = (1 - $x) * 0.5 * $PI + $x * $y * ASin(Sqrt($h2) / Cos($beta1))
    Local $A2s = (1 - $x) * 0.5 * $PI + $x * $y * ASin(Sqrt($h2) / Cos($beta2))
    If $FALL = 2 Then $A2s = $PI - $A2s
    If $A1 < 0 Then $A1 += 2 * $PI
    If $A2s < 0 Then $A2s += 2 * $PI
    Local $A2 = $A2s + $PI
    If $A2 > $PI Then $A2 -= 2 * $PI

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

    ; Berechnung der Streckenlänge
    ; Integrationsgrenzen v1 und v2 bestimmen
    Local $v1 = ASin(Sin($beta1) / Sqrt(1 - $h2))
    Local $v2 = ASin(Sin($beta2) / Sqrt(1 - $h2))

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

    If (Abs($deltaLsoll - $PI) < 1E-10) Then $FALL = 2 ; check ob deltaLsoll = Pi
    If $FALL = 2 Then $v2 = Sign($B1 + $B2) * $PI - $v2

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

    ; Berechnung der Streckenlänge durch numerische Intergration
    $s_Funktion = "sqrt(1-" & $e2 & "*(1-sin(x)*sin(x)*" & 1 - $h2 & "))"
    Local $S = $a * _MathInt_Romberg($s_Funktion, $v1, $v2, $EPS) ; Strecke zwischen beiden Punkten in m

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

    Local $a_Ret = [$S, $A1, $A2]
    Return $a_Ret
    EndFunc ;==>_Ellipsoid_DistanceOf2Points

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

    #Region Hilsfunktionen
    ; Signum (Vorzeichen) einer Zahl
    Func Sign($x)
    Return ($x < 0) ? -1 : ($x > 0) ? 1 : 0
    EndFunc ;==>Sign

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

    ; #=============================================
    ; = _Coords_GeoData2Degrees =
    ; =============================================*
    ; Wandelt Koordinaten im Geodata-Format (z.B. E-2-20-14-N-48-50-11) - in normale Dezimalwinkel
    Func _Coords_GeoData2Degrees($s_GeoDataForm)
    ; by AspirinJunkie
    Local $aTemp = StringSplit($s_GeoDataForm, "-", 3)
    Local $t_Ret = DllStructCreate($TAG_GEOCOORD)
    $t_Ret.L = ($aTemp[1] * 3600 + $aTemp[2] * 60 + $aTemp[3]) / 3600 * (($aTemp[0] = "W") ? -1 : 1)
    $t_Ret.B = ($aTemp[5] * 3600 + $aTemp[6] * 60 + $aTemp[7]) / 3600 * (($aTemp[4] = "S") ? -1 : 1)
    Return $t_Ret
    EndFunc ;==>_Coords_GeoData2Degrees

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

    ; #=============================================
    ; = _Coords_Degree2Hour =
    ; =============================================*
    ; Wandelt Koordinaten in Dezimalform in Winkel:Minute:Sekunde-Form (Bogenminuten)
    Func _Coords_Degree2Hour($t_Degree)
    ; by AspirinJunkie
    Local $t_Ret = DllStructCreate($TAG_GEOCOORD_HOUR)

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

    $t_Ret.bD = Int($t_Degree.B)
    Local $temp = $t_Degree.B - $t_Ret.bD
    $t_Ret.bM = Int(60 * $temp)
    $t_Ret.bS = Abs(3600 * $temp - 60 * $t_Ret.bM)
    $t_Ret.bM = Abs($t_Ret.bM)

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

    $t_Ret.lD = Int($t_Degree.L)
    $temp = $t_Degree.L - $t_Ret.lD
    $t_Ret.lM = Int(60 * $temp)
    $t_Ret.lS = Abs(3600 * $temp - 60 * $t_Ret.lM)
    $t_Ret.lM = Abs($t_Ret.lM)
    Return $t_Ret
    EndFunc ;==>_Coords_Degree2Hour

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

    ; Gibt die Koordinaten im Bogenminuten-Format als String zurück
    Func _Coord_PrintHour($t_Hour)
    ; by AspirinJunkie
    Return StringFormat("Lat: %2d° %2d' %2d"".%05d %1s\tLon: %2d° %2d' %2d"".%05d %1s", _
    Abs(Int($t_Hour.bD)), $t_Hour.bM, Int($t_Hour.bS), Int(StringLeft(StringTrimLeft($t_Hour.bS, StringLen(Int($t_Hour.bS)) + 1), 5)), ($t_Hour.bD >= 0) ? "N" : "O", _
    Abs(Int($t_Hour.lD)), $t_Hour.lM, Int($t_Hour.lS), Int(StringLeft(StringTrimLeft($t_Hour.lS, StringLen(Int($t_Hour.lS)) + 1), 5)), ($t_Hour.lD >= 0) ? "E" : "W")
    EndFunc ;==>_Coord_PrintHour
    #EndRegion Hilsfunktionen

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

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

    [/autoit]


    Ein Hinweis vielleicht noch: Bei deinem Koordinatenparsing negierst du die Koordinatenangaben wenn sie Ostkoordinaten sind. Normal ist es aber eigentlich Westkoordinaten zu negieren.
    Am Ergebnis ändert das aber nichts - eher ein Schönheitsdetail.

    Ein sehr schönes Online-Tool mit dem man sich das ganze berechnen und vor allem anzeigen lassen kann ist hier zu finden: http://geographiclib.sourceforge.net/scripts/geod-google.html (unser Anwendungsfall ist der "Inverse")

    Edit: Hab auch mal die Azimutwinkel im Anfangs und Endpunkt mit hinzugefügt, damit man weiß in welche Richtung man loslaufen muss und in welche man ankommt.
    Edit2: Auf Romberg-Integration umgestellt.
    Edit3: Link zum Online-Tool hinzugefügt

  • FTP - Wechsel in ein übergeordnetes Verzeichnis

    • AspirinJunkie
    • 7. August 2014 um 13:07

    Bist du sicher, dass du das Skript bis auf die Variablen $server, $username, $pass und $directory unangetastet gelassen hast?
    Weil in der Messagebox sollte als erstes "Return: " stehen.
    Bei dir steht aber schon der Inhalt des Rückgabewertes.

    Nun habe ich doch noch ein paar Fragen:

    Zitat von Grandpa

    Er kann das Verzeichnis nicht finden. Klar, denn der Inhalt des Verzeichnisses, in dem er sich aktuell befindet sieht folgendermaßen aus (ein Ausschnitt):

    Das verstehe ich nicht warum das klar sein soll - was hat dies mit dem aktuellen Ordner zu tun?
    Die Fehlemeldung sagt für mich aus: Auf dem verbundenen FTP-Server gibt es keinen Ordner namens /var/app/mt2inet/log/tomcat-7.0.27-inst1/
    Du willst in den Ordner /var/app/mt2inet/log/tomcat-7.0.27-inst1/ wechseln?
    Warum befindest du dich zu diesem Zeitpunkt schon in, laut deiner Aussage, /app/mt2/ftp/efn/?
    Im Testkript gibt es doch nur ein FtpSetCurrentDirectory?
    Du solltest dich also im Ursprungszustand im Root-Verzeichnis befinden.

    Zitat von Grandpa

    Jetzt kennst du die eigentliche Verzeichnisstruktur.

    So wirklich nicht - du redest auf einmal von zwei verschiedenen Verzeichnissen obwohl wir ein FtpSetCurrentDirectory auf nur ein bestimmtes testen wollten.
    Ist /var/app/mt2inet/log/tomcat-7.0.27-inst1/ nur ein Unterordner von /app/mt2/ftp/efn/?
    Pfadangaben bei FtpSetCurrentDirectory sind immer vom Wurzelverzeichnis aus gemeint - nicht als Unterordner eines aktuellen Verzeichnisses.

    Zitat von Grandpa

    PPS: Warum sollte ich Grampa heißen. Verstehe grad den Witz dahinter nicht. Simpson Grandpa heißt doch Abe?

    Grampa bei den Simpsons wird nicht Grandpa sondern Grampa geschrieben.

  • InetGet() ladet Fehlerhaft Dateien runter

    • AspirinJunkie
    • 6. August 2014 um 15:43

    Wie sieht es mit der Fehlerbehandlung aus?
    Was sagt denn @error?
    Funktioniert es stattdessen mit InetRead und anschließendem FileWrite?

  • InetGet() ladet Fehlerhaft Dateien runter

    • AspirinJunkie
    • 6. August 2014 um 14:07

    Irgendein Beispielskript bei dem man dein Handeln nachvollziehen kann?
    Wichtig wäre vor allem ein Minimalbeispiel - also ein Skript welches den Fehler reproduziert und dabei möglichst alles andere entfernt hat und welches direkt ohne weitere Änderung ausgeführt werden kann.

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™