Kompilierender Matheparser

[Dax]

Ich glaube, das sprengt schon sehr den Rahmen des Parser ;)

Aber: Weil das Ding wirklich verdammt schnell ist, könnte ich versuchen eine Approximationsmethode (:mrgreen:) einzubauen, die die Formel so lange durchrechnet, bis x bis zu einer gewissen Grenze mit der wirklichen Lösung übereinstimmt (manche wissenschaftliche Taschenrechner bieten solche Lösungsmethoden auch an). Wäre das was? ;)

read you,
Dax

[DGL-luke]

es gibt doch variablen in dem parser, oder? kann er also nicht

(lg(x))² - lg(4x-4)

so auflösen, dass zum schluss der term halt etwas einfacher da steht?

[Dax]

Ich fürchte nicht :?

Der Parser wandelt die Formel intern in einen Stream aus Funktionsaufrufen um, ohne wirklich zu "wissen", was er da tut. Das eigentliche lösen der Formel wird auch nicht vom Parser übernommen, sondern von den registrierten Funktionen und Operatoren. In der Hinsicht sehe ich im Moment keine wirkliche Möglichkeit, aber wenn du denkst, du könntest es einbauen, nur zu :)

read you,
Dax

[DGL-luke]

was, ich denke? um himmels willen nein.....

wenn ich so gut in mathe wär, dass ich das könnte, würd ich nicht danach fragen, ob der parser meine hausuafgaben machen kann.... :stupid:

aber das mit dem approximationsverfahren wär natürlcih ne idee - ich kann da aber wirklcih nix machen. kenn mich da weder in theorie noch in praxis damit aus.

[Dax]

Danke Anakin (;)), ich seh mal zu, das es irgendwann kommt :)

[jim_raynor]

Ich lebe noch ;) und komme gleich mit dem nächsten Problem. Diesmal wieder die Formel vom Anfang. Am besten du machst dir mal ein Testprogramm, in dem alle Formeln drin sind, berechnet werden und das Ergebnis geprüft wird. Testet sich vermutlich leichter ;)

Delphi-Quellcode:

  Parser:=TExCQParser.Create;
  Parser.SolveMode:=smVM;
  Parser.PreSolve:=true;

  Parser.RegisterVariable('BaseRange');
  Parser.RegisterVariable('Range');
  Parser.RegisterVariable('UnitTreff');

  Parser.SetVariable('BaseRange',[10]);
  Parser.SetVariable('UnitTreff',[8]);
  Parser.SetVariable('Range',[10]);

  Parser.Parse('UnitTreff*(1/(Range*Range))*(BaseRange*BaseRange)');

  ShowMessage(FloatToStr(Parser.Solve.X));
  Parser.Free;

[Dax]

Huhu :)

Ich hab den Serializer für den numeralen Stack einmal komplett neu geschrieben und den Parser mit allen mir zur Verfügung stehenden Parsermörderformel (;)) getestet - erfolgreich :)

ThisThread.NewVersion; ;)

read you,
Dax

[jim_raynor]

Zitat:

Zitat von Dax

Ich hab den Serializer für den numeralen Stack einmal komplett neu geschrieben und den Parser mit allen mir zur Verfügung stehenden Parsermörderformel (;)) getestet - erfolgreich :)

Hehe. Willst jetzt damit sagen, dass du meine Formeln fest einprogrammiert hast? :lol:
Hehe. Nein natürlich nicht. Schaue es mir mal heute Abend mal an und such nach den Formeln, die du noch nicht kennst ;)

[jim_raynor]

Der neue Serializer scheint wirklich gut zu funktionieren ;) Falls ich ne Formel finde, die den deine Komponente ins schleudern bringt, melde ich mich ;)

Ach ja, was hälst du denn davon Funktionen wie min und max mit einzubauen?

[Dax]

Zitat:

Zitat von jim_raynor

Der neue Serializer scheint wirklich gut zu funktionieren ;) Falls ich ne Formel finde, die den deine Komponente ins schleudern bringt, melde ich mich ;)

Macnhmal sieht man eben den Wald vor lauter Bäumen nicht ;)

Zitat:

Zitat von jim_raynor

Ach ja, was hälst du denn davon Funktionen wie min und max mit einzubauen?

Werde ich im nächsten Release machen ;)

Bis dahin kannst du es ja selbst machen :mrgreen: Kuck dir einfach mal die ExCQP_PreDef.pas an, dort wird unter anderem (auch wenns nicht ganz Absicht war ^^) gezeigt, wie man Funktionen und Operatoren registriert :)

read you,
Dax

[nailor]

Zitat:

Zitat von DGL-luke

weisst du, was genial wäre? wenn der parser gleichungen (bzw. eine seite einer gleichung) lösen (bzw. vereinfachen) könnte.

nur als kleine anregung :)

Zitat:

Zitat von Dax

Sag mal ein konkretes Beispiel, dann überleg ichs mir :)

read you,
Dax

Hi Heute!

Ich hab die letzten Tage mal mit C# ein bisschen Parser gebastelt (nur zu meinem Vergnügen). Aber das ist echt nen Thema, für das ich mich begeistern könnte (glaub ich, von dem was ich bisher gemacht habe her). Plus Minus Mal Durch Hoch... (normale binäre Operatoren -> check). Operator Precedence (-> check). Klammern (-> check). Ein Protokoll führen. Das geht ja alles ganz schick.

Aber was mir dann recht schnell in den Sinn kam, war das Lösen von Gleichungen (erstmal aufgrund simpler Umformungen). Es müssten [irgendwann] natürlich auch so Sachen wie "Rechenweg anzeigen" und "benutzerdefinierte Formelsammlung" gehen. Die Formelsammlung sollte im Endeffekt ermöglichen, quasi alle Gleichungen (Ungleichungen) zu Lösen, die man sich so vorstellen kann. Natürlich mit allen Anmerkungen (Rechenweg, Annahmen...).

Also weniger (aber auch, die Basis muss stehen) Numberchrunchen, sondern auch nen schickes Drumrum auf höherem Level wie es z.b. Derive bietet. Bei Interesse wäre ich bereit, mal genauer _mit_-zuplanen.

Michael

[Dax]

Interesse besteht garantiert, alle potenziellen Mitarbeitenwoller sind herzlich eingeladen :)

[Dax]

Ahhh :wall: Ich hab grad einen tödlichen Fehler im Serializer ausgebügelt.. :roll: Aber die wieder mal neue Version sollte jetzt wirklich funktionieren.. Was ich zwar nicht glaube, weils bisher nie richtig geklappt, aber den Versuch ist es ja wert ;)

read you,
Dax

[Dax]

Hallo mal wieder ;)

Die jetzige Version hat nur eine Neuerung: die von Dust Signs indirekt geforderte Information über die Fehler ;)

read you,
Dax

[tyberis]

Na Hallo!
Ich bin gewissermassen dein Konkurrent und wollte jetzt auch mal meinen Senf dazu geben (da mein Parser bisher erfolgreich ignoriert wurde ;)).

Hier eine Liste von noch falsch interpretierten Ausdrücken:
-2^2 => 4 (statt -4)
-(1/2) => Access Violation
(1-2)+3 => Access Violation
a^b^c => Hoch wird standardmässig oft rechtsgeklammert (siehe z.B. Definition der Gausschen Glockenkurve (keine explizite Klammerung) vs. Potenzgesetz (explizite Klammerung))

Sonst cool :)

[Dax]

Zitat:

Zitat von tyberis

Na Hallo!
Ich bin gewissermassen dein Konkurrent und wollte jetzt auch mal meinen Senf dazu geben (da mein Parser bisher erfolgreich ignoriert wurde ;)).

Hier eine Liste von noch falsch interpretierten Ausdrücken:
-2^2 => 4 (statt -4)

Sorry, aber in meinem Kontext stimmt das ;) Der Parser wertet den Ausdruck als (-2)^2, also...

Zitat:

Zitat von tyberis

-(1/2) => Access Violation
(1-2)+3 => Access Violation

Korrigiert, neue Versionen oben :)

Zitat:

Zitat von tyberis

a^b^c => Hoch wird standardmässig oft rechtsgeklammert (siehe z.B. Definition der Gausschen Glockenkurve (keine explizite Klammerung) vs. Potenzgesetz (explizite Klammerung))

Hmm.. Der Parser rechnet von links nach rechts, vielleicht sollte ich mir das mal ansehen ^^

Zitat:

Zitat von tyberis

Sonst cool :)

Danke :)

read you,
Dax

[DGL-luke]

Zitat:

Zitat von Dax

Zitat:

Hier eine Liste von noch falsch interpretierten Ausdrücken:
-2^2 => 4 (statt -4)

Sorry, aber in meinem Kontext stimmt das ;) Der Parser wertet den Ausdruck als (-2)^2, also...

x^n = |x^n| für alle {n | n mod 2 = 0}

wenn dir diese notation geläufig ist.... :wink:

man könnte auch sagen alle geraden exponenten erzeugen ein positives ergebnis, aber auf das niveau müssen wir uns ja nicht herablassen :mrgreen:

EDIT: oha, ich habe wohl was verwechselt. er bemängelt ja nicht, dass das ergebnis -4 IST, sondern dass es seiner Meinung nach -4 SEIN SOLLTE.
womit dax natürlich absolut recht hat. also nix für ungut.

[alcaeus]

Zitat:

Zitat von DGL-luke

man könnte auch sagen alle geraden exponenten erzeugen ein positives ergebnis

Naja, es kommt drauf an wie man -2^2 interpretiert: (-2)^2 = 4, waehrend -(2^2) = -4. Dort liegt der Unterschied: wo gehoert das Minus hin ;)

Greetz
alcaeus

[nailor]

da es sich hier imho um den unären vorzeichen-wechsel-operator handelt (und nicht um nen dummes rechen-minus) hat es einen höheren "rang" als das potenzieren, und sollte zuerst ausgewertet werden, also

(-2)^2 = 4

[Dax]

Da hat nailor recht ;)

Das - als Präfix negiert die nachgestellte Zahl/Variable mit höchster Priorität. Die unär-Präfixe werden sowieso als allererstes ausgewertet, auch vor den Postfixes ;)

[nailor]

btw: du hast zwei demo-exen zum download. kannst du mal jeweils ne kleine beschreibung dazumachen oder irgendwie anders deutlich machen, was was ist?

[Dax]

Zwei? Das wäre mir neu. Da sollte nur eine sein, und zwar die im ersten Beitrag. Und die ist dazu gedacht, zu demonstrieren, was das DIng so drauf hat ;)

[nailor]

Code:

 Beschreibung:           
Download
 Dateiname:     ECQPDemo-Exe.zip
 Dateigröße:     233,04 KB     Heruntergeladen:     33 mal

 Beschreibung:         
Download
 Dateiname:     ExCQParser.zip
 Dateigröße:     18,34 KB     Heruntergeladen:     110 mal

 Beschreibung:         
Download
 Dateiname:     ECQPDemo-Exe.zip
 Dateigröße:     233,01 KB     Heruntergeladen:     68 mal

[DGL-luke]

na an den dateigrössen sieht man ja wohl, dass das zwei mal die selbe demo ist, aber wohl in verschiedenen versionen.
würd ich jetzt vermuten.

[Dax]

Sorry, da muss beim Upload was schief gelaufen sein.. jetzt müssts aber stimmen :oops:

[tyberis]

-2^2 = -(2^2) = -4 (<- diskussionslos)

Hmm, hast du schon mal ein Polynom gesehn?
-x^2+x+1 interpretiert man ganz bestimmt nicht als (-x)^2+x+1; sondern als -(x^2)+x+1

Glaube wohl kaum, dass du einen Taschenrechner findest, der anders rechnet ;)

[Dax]

Na ja, dann werde ich mal wieder was ändern müssen. Das unäre - wird wohl eine Variable ^^

Edit: Hm, nö, geht nicht als Variable. :?

Noch eins: Jetzt gehts ;)

[Dax]

Sooo mal wieder eine neue Version ;) Diesmal sind wieder ein paar Bugs raus.. der Presolver hat manchmal noch ein wenig Mist gebaut, und Variablen und Funktionen entfernen war noch Case-sensitiv. Ansonsten.. nix :)

read you,
Dax

[jim_raynor]

Hi, hast ja lange nichts mehr von mir gehört. Heisst nur dass ich keine Probleme hatte ;)

Habe jetzt mal wieder MemCheck (http://v.mahon.free.fr/pro/freeware/memcheck/) zum Laufen gebracht und musste feststellen, dass einige Objekte nicht vernüftig freigegeben werden. Werde bestimmt nicht verkehrt, wenn du mal versuchts die MemoryLeaks zu beseitigen.

[Dax]

Hmm.. Erst mal sollte ich wieder Delphi installieren, am besten mach ich das sofort. UNd danke für den Tip ;)

Ich würde mal vermuten, das da einige Variablen noch Zerstört werden, wer weiß was da schiefgelaufen ist..

[Dax]

So, die Memory Leaks sind alle ausgebügelt :) Musste beim Assemblieren leider auf Strings umsteigen..

Na ja, viel Spass mit der neuen, verbesserten Version ;)

Edit: Ein kleines Problem mit der Assemblage ist jetzt auch behoben :)

[negaH]

@Dax,

inwieweit kann man den benutzten Datentyp der Berechnungen verändern ? Anders gefragt: kann man deinen Parser unabhängig vom Datentypen wie zb. Double machen ?
Hintergrund meiner Fragen ist es das ich einen solchen Parser suche der zb. mit meinen supergroßen Integern arbeiten kann.

Gruß Hagen

[Dax]

Klar, der Parser kann rein theoretisch sogar mit Pointern rechen ;) Alles, was dazu anzupassen wäre, sind ECQP_Def.TFloat und eben die Berechnungsroutinen in der Unit ExCQPreDef (ich hoff die Namen stimmen ;))

Darüber hinaus ist wirklich nichts nötig, da die Variablen von einer Klasseninstanz beherbergt werden. Klasseinstanzen sind ja bekanntlich Pointer, und nur diese Pointer werden auf dem Eval-Stack rumgeschoben, was an und für sich schon einen enormen Geschwindigkeitsvorteil bringt. Ich hätte nie damit gerechnet, das jemand den Parser für deine Riesenzahlen modifizieren wöllte, aber dem steht nichts im Wege :)

read you,
Dax

[drstar]

Hallo, Leutz! Bin grad dabei, ein umfangreiches Matheprogramm mit Formeleditor etc. zusammenzubasteln, da kommen mir diese Codeschnipsel wie gerufen. Werd mal sehen, ob ich sie problemlos in mein Matheprogramm implementieren kann. Sieht aber auf jeden Fall seh interessant aus, werd in Kürze mein Projekt vorstellen (hoffe,daß es jetzt deutlich schneller fertig wird...).

[DP @ Home]

Hi,

ich wollte nur mal einen Fehler bemerken, der mir gerade unterkam. Evtl. ist der bekannt, aber alles hier zu lesen... Nun ja ;-)

Wenn ich als Formel (Beispiel aus dem 4. Beitrag) folgende eingebe: 2+4, dann rechnet er fein. Wenn ich 2+A eingebe, dann rechnet er auch fein, wenn ich 2+4+4 eingebe, macht er mich weiterhin glücklich. Gebe ich aber 2+A+4 ein, dann wirft er mir eine AV entgegen :-/

:witch:

P.S: Diese Fehler kommen im Modus smRM, im Modus smVM geht es gut ;)

[DP @ Home]

Zitat:

Zitat von DP @ Home

ich wollte nur mal einen Fehler bemerken, der mir gerade unterkam. Evtl. ist der bekannt, aber alles hier zu lesen... Nun ja ;-)

Hm... ist das Projekt eingestellt oder wird es doch noch ein Update geben :cry:

[Dax]

Ohhh sorry Leute, hab den Thread vollkommen aus den Augen verloren.. :oops: Das Projekt ist natürlich nicht (vollkommen *hust*) eingestellt, aber wenn ich mir meinen Code so ansehe.. Da ist sehr viel Optimierungspotenzial. Vor allem beim smRM.. Und ne Menge Fehler wies aussieht auch.

Ich glaube ich werd das Ding mal fast komplett neu schreiben, diesmal aber ein wenig anders. Das Interface wird nach Möglichkeiten so gleich bleiben wies nur geht, und das ganze sollte wirklich schneller sein ;)

Wenn niemand Einspruch erhebt natürlich, ansonsten behalt ich diese Sourcen bei :)


*thread vorsichtshalber markier*

[sniper_w]

Zitat:

Wenn niemand Einspruch erhebt natürlich

Einspruch, Euer... :zwinker:

[Dax]

Einspruch abgewiesen :mrgreen:

Aber mal ernsthaft: Was spricht denn dagegen, intern alles zumindest ein wenig neu zu schreiben und damit vielleicht stabiler? Nur aus Interesse :)

[Daniel G]

Spontan würde ich sagen:

Nix!

Solange es nicht ein Jahr dauert... :zwinker: