Suche Lösungsansatz zum Verbessern des Parsen von Funktionen

[SimStar001]

Hallo,

ich bin auf der Suche nach einem Lösungsansatz zum Verbessern des Parsen von mathematischen Funktionen.

Zur Zeit parse ich die Funktionen rekursiv, d.h. die Funktion wird umgekehrt der Rechenregeln nach den entsprechenden Operatoren durchsucht und geparst. Hier mal ein ganz einfaches Beispiel:

f(x) = 3*x^2-4

Parsen durch Funktion:

Schritt 1: 3*x^2 - 4
Schritt 2: 3*x - 2
Schritt 3: 3 * x
Schritt 4: für x einen Wert einsetzen und rückrechnen
Schritt 5: alles zusammenrechnen


So ich hoffe das Prizip wird deutlich.

Nun ist es aber so, dass wenn ich z.B. für eine Untersuchung der Funktion in einem bestimmten Intervall durchfüher, jede Menge Funktionswerte brauche, und somit die Funktion für jeden einzellnen Wert erneut parsen muss, was am Ende doch jede Menge Zeit kostet.

Nun wäre meine Frage, ob es nicht irgendwie möglich ist, die Funktion nach dem Prinzip zu parsen, jedoch die einzellnen Teile irgendwie gespeichert werden können, um nacher bei der Funktionswertberechnung, die Funktion nicht jedesal einlesen zu müssen, sondern sofort mit dem Rückrechnen begonnen werden kann.

Nun, wäre sowas möglich, wenn ja wie? Ich habe mir da schon mal Gedanken gemacht, komme aber zu keiner vernünftigen Lösung, bzw. scheitere immer an der Speicherung, und der entsprechenden Rückrechnung.

Wie würdet Ihr das Lösen? Oder gibts irgendwo dazu schonmal nen Ansatz? vielen Dank!
LG Marco!

[mkinzler]

Es gibt schon diverse fertige Matheparser.
http://www.efg2.com/Lab/Library/Delp...ns/Parsers.htm
Mathe Parser

[SimStar001]

Ist mir klar, hab auch einen Funktionsplotter programmiert, nur geht es mir halt um die Lösung des Problems, und nicht darum, dass es sowas schon gibt! Haste nen Vorschlag oder nicht?

[mkinzler]

Die DP scheint zum Selbstbedienungsladen zu mutieren, in dem man blöd angemacht wird, wenn man helfen will, aber keine 100%-Lösung bietet. :gruebel:

[SimStar001]

Sorry wenn es so rüber kam, aber ich wollt dich weder anmachen noch sonstwas! Also fühl dich bitte nicht gleich auf den Schlips getreten.

Problemstellung ist halt das speichern von Elementen, die durch die Rekursive bearbeitung erzeugt werden um dann bei bedarf immer wieder zurückzurechnen, ohne immer wieder einlesen zu müssen!

[Khabarakh]

Zitat:

Zitat von SimStar001

Nun wäre meine Frage, ob es nicht irgendwie möglich ist, die Funktion nach dem Prinzip zu parsen, jedoch die einzellnen Teile irgendwie gespeichert werden können, um nacher bei der Funktionswertberechnung, die Funktion nicht jedesal einlesen zu müssen, sondern sofort mit dem Rückrechnen begonnen werden kann.

Exakt. Statt sofort auszurechnen, musst Du beim Parsen einen AST erstellen. Könnte im Design z.B. so aussehen:

Delphi-Quellcode:

type
  TOp = class
    function Evaluate: Float; virtual; abstract;
  end;

  TBinaryOpKind = (bokPlus, bokMinus, bokMul, bokDiv);

  TBinaryOp = class(TOp)
    constructor Create(aKind : TBinaryOpKind; aLeft : TOp; aRight : TOp);
    function Evaluate: Float; override;
  end;

  TUnaryOp = class(TOp) [...] // Minus, ggf. sin, Fakultät etc.

  TVariableOp = class(TOp) // Literale("3.14"), Konstanten und Variablen
    constructor Create(aVar : TVar);
    function Evaluate: Float; override;
  end;

[...]

function TBinaryOp.Evaluate : Float;
begin
  case fKind of
    bokPlus : Result := fLeft.Evaluate + fRight.Evaluate;
  ...
end;

function TVariableOp.Evaluate : Float;
begin
  Result := fVar.Value;
end;

Ich hoffe, ich konnte das Konzept klar machen :? .

Einen Schritt weiter wären wir dann bei kompilierenden Parsern, da könntest du dich von Dax inspirieren lassen.

[SimStar001]

Vielen Vielen Dank, ich werde mir das ganze mal ansehen, und ausprobieren.

Vielen Dank!

[SimStar001]

Also ich habe mir mal die Referenzen angesehen und versucht dahinter zu steigen, auch mit deinem Beispiel, aber ich steig irgendwie nicht hinter den Grundaufbau... :gruebel: :gruebel: :gruebel:

Ich habe irgendwie ein Problem damit zu verstehen, wie man eine Klasse definiert, in der dann alle Daten stecken, sprich die Einzelnen Nodes und Branches. Vielleicht kann mir das ja mal jemand versuchen zu erklären, oder vielleicht hat ja jemand noch einen Link, der das sehr gut erklärt.


Vielen Dank!

[Khabarakh]

Zitat:

Zitat von SimStar001

Ich habe irgendwie ein Problem damit zu verstehen, wie man eine Klasse definiert, in der dann alle Daten stecken, sprich die Einzelnen Nodes und Branches.

Eigentlich dachte ich, genau das vorgestellt zu haben :stupid: :( .
Schau dir mal TBinOp, die Klasse für alle binären Operatoren wie +,-,*,/ an: Der Konstruktor nimmt zwei weitere TOps entgegen, das sind die mit diesem Binary-Node verknüpften Branches.
Um mal dein Beispiel 3*x^2-4 umzusetzen:

Delphi-Quellcode:

TBinOp(
  Kind = bokMinus,
  Left = TBinOp(
    Kind = bokMul,
    Left = TConstantOp(Value = 3),
    Right = TBinOp(
      Kind = bokPower,
      Left = TVariableOp(
        Var = TVar(Name = "x", Value = ...)
      ),
      Right = TConstantOp(Value = 2)
    ),
  ),
  Right = TConstantOp(Value = 4),
)

Habe mal zur Übersicht doch noch eine TConstantOp-Klasse eingeführt.
Wenn du das Zeile für Zeile durchgehst, sind wir übrigens bei der Polnischen Notation :D : - * 3 ^ x 2 4

[Corpsman]

Mein GenMathCalc parst die Ausdrücke mit maximaler Rekursionstiefe 2, das muste ich sogar mal beweisen ;) .

Evtl kannst du aus dem source ein paar ideen hohlen ..