Newsgroup: it.comp.lang.visual-basic
Titolo: [OT] Infix --> Postfix

Ciao a tutti,
Forse qui c'è qualche universitario che può aiutarmi.
Sto cercando il modo di convertire le formule dalla classica notazione Infix
a quella Postfix.
Per formule nella forma canonica non c'è problema, la documentazione in
internet è piuttosto ampia, anche se ho dovuto faticare un po' per le
funzioni con più parametri.
Il problema è convertire correttamente la forma "dotted" dei moderni
linguaggi ad oggetti, es:
non
    cos(x) + sin(y)
ma
    x.cos() + y.sin()
che in entrambi i casi dovrebbe divenire
    x cos y sin +
Qualcuno ha qualche dritta?
O sa dove indirizzarmi per la richiesta?
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 Qualcuno ha qualche dritta?
Non ho capito bene quale sia il tuo problema.
Non potresti spiegarti in modo più "pratico"?
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 Non potresti spiegarti in modo più "pratico"?
come dicevo, per la forma
    cos(x) + sin(y)
non ci sono problemi, ma non ho idea di come fare a convertire in Postfix la
forma
    x.cos() + y.sin()
Forse in qualche libro universitario c'è qualcosa...


 Ciao
UH!faccio nella mia ignoranza notare una cosina...che sicuramente già
sai....
cos(x)
per me è diverso da cos()
...anzi non è valido!
a meno di non considerare (nel tuo parser) cos()=cos(0)
e
allora
x*cos (0)
è diverso da cos(x)
a meno che tu non stiano considerando non tanto la matematica ma il "modo"
di scrivere l'equazione
alla rpn per intendersi.....
ma siccome scrivendo capisco che è proprio questo che intendi....
ti aiuta questo?
http://www.c-sharpcorner.com/Code/2002/April/ExpressionEvaluator.asp
(tanto a differenza di me tu di NET ne capisci!)
...e questo...?
http://www.codeguru.com/cs_misc/Function.html
Saluti!

 
Tanto per chiarire, cos(log(x)) come lo traduci?
1^ ipotesi: (x.log()).cos()
2^ ipotesi: y=x.log()
            risultato = y.cos()
Bye by SixaM 8-]
--
Bye by SixaM 8-]
Inviato da 
www.mynewsgate.net

 (tanto a differenza di me tu di NET ne capisci!)
Sì, certo... :)
Ciao

 1^ ipotesi: (x.log()).cos()
Anche, o più semplicemente x.log().cos(), nel caso di Form1 anzichè 
scrivere GetCaption(GetLabel1(Form1)) sciverei Form1.Label1.Caption
Chiaro?
Non fossilizziamoci sul nome delle funzioni che ho scelto, ma sul metodo 
di scrittura.
Ciao

> (tanto a differenza di me tu di NET ne capisci!)
sigh mi offenderei pure e ti direi che son problemi tua......
ma siccome scherzo un po.....il link aveva un link ad un code...che
conteneva anche sta funzionicchia
.....A scanso di equivoci.....
se va bene a quello che vuoi far te non lo so....
non č in vb....
...non so che faccia....
il nome sembrerebbe una cosa valida.....perň sai....basterebbe tirar giu
l'esempio e veder se fa qualcosa che a te č utile
....non avrň capito quello che vuoi fare
.....ma se mi tratti cosě un altra volta ti stacco le pile dal portatile e
te le attacco ai canini!
tič!
;-D
.............
public void Infix2Postfix()
{
Symbol tpSym;
Stack tpStack = new Stack();
foreach(Symbol sym in m_equation)
{
if((sym.m_type == Type.Value) || (sym.m_type == Type.Variable))
m_postfix.Add(sym);
else if((sym.m_name == "(") || (sym.m_name == "[") || (sym.m_name == "{"))
tpStack.Push(sym);
else if((sym.m_name == ")") || (sym.m_name == "]") || (sym.m_name == "}"))
{
if(tpStack.Count > 0)
{
tpSym = (Symbol)tpStack.Pop();
while((tpSym.m_name != "(") && (tpSym.m_name != "[") && (tpSym.m_name !=
"{"))
{
m_postfix.Add(tpSym);
tpSym = (Symbol)tpStack.Pop();
}
}
}
else
{
if(tpStack.Count > 0)
{
tpSym = (Symbol)tpStack.Pop();
while((tpStack.Count != 0) && ((tpSym.m_type == Type.Operator) ||
(tpSym.m_type == Type.Function) || (tpSym.m_type == Type.Comma)) &&
(Precedence(tpSym) >= Precedence(sym)))
{
m_postfix.Add(tpSym);
tpSym = (Symbol)tpStack.Pop();
}
if(((tpSym.m_type == Type.Operator) || (tpSym.m_type == Type.Function) ||
(tpSym.m_type == Type.Comma)) && (Precedence(tpSym) >= Precedence(sym)))
m_postfix.Add(tpSym);
else
tpStack.Push(tpSym);
}
tpStack.Push(sym);
}
}
while(tpStack.Count > 0)
{
tpSym = (Symbol)tpStack.Pop();
m_postfix.Add(tpSym);
}
}
.............sotto c'č altra roba ma io c'ho da fŕ! .....arrŕngete!
:-P
bai bai!
splonk!

     x.cos() + y.sin()
Dividi le due espressioni x.cos() e y.sin() tenendo presente l'operatore
esattamente come avresti fatto con cos(x) + sen(x), poi partendo da
sinistra separi l'oggetto (la x) dalle funzioni che ci devi applicare, 
stando attento, nel caso di un numero, che il primo punto a sinistra non
sia un separatore decimale (2.34.sin() per esempio).
Quindi x.log().sin().cos() diventa facilmente x log sin cos in perfetto
stile rpn... se ho capito bene il tuo problema (ma questa è una
settimana in cui ho 4 esami, quindi sono un po' fuso...).


 settimana in cui ho 4 esami, quindi sono un po' fuso...).
Non c'è problema, io lavoro, quindi sai la voglia che ho durante la
settimana :)


 x sin cos.
Secondo me non è una buona idea ammettere forme "miste".
O si usa una sintassi del tipo x.sin() o si usa una sintassi del tipo
sin(x).
