Newsgroup: it.comp.java
Titolo: Leggere e valutare espressioni booleane correttamente

Salve a tutti,
sto preparando un progetto per l'università e mi trovo davanti ad un
piccolo ma insidioso(almeno per me!) problema,cioè dovrei valutare delle
espressioni contenenti valori booleani del tipo:
((espr1 & espr2 | espr3) | espr4)
in cui ogni variabile espr contiene un booleano.
Il risultato è chiaramente dato dall'AND o dall'OR applicati su tali
valori,ma non riesco a creare un codice in grado di leggere
correttamente l'espressione ovvero in gradi di scomporla in maniera
esatta.
Per es. dovrei  prima svolgere (espr1 & espr2 | espr3) e sostituirla con
il rispettivo valore booleano per poi fare l'OR con espr4.
Qualche idea o trucchi da consigliarmi??
Ve ne sarei grato.
Saluti,
Luca


hai bisogno un parser.
guarda antLR.
Ciao Jack


Un bel casino..non ho mai usato questo tool e mi sembra alquanto
sofisticato,mi sa che devo trovare un'altra soluzione.

 sofisticato,mi sa che devo trovare un'altra soluzione.
ti assicuro che scrivere un parser a mano e' molto piu' incasinato che
usare questo tool
Ciao Jack

 Ciao Jack
quoto tutto.
sv.

Jack ha scritto:

Uhmmmm ...... e' il primo che ho trovato
http://www.openbookproject.net/thinkcs/java/english/chap17.htm
particolare attenzione a 17.4 e 17.5
Se e' per motivi di "studio" credo che la soluzione dovrebbe essere 
senza l'uso di "prefabbricati"
--
ac

 Qualche idea o trucchi da consigliarmi??
Un paio di alternative a quanto ti hanno già suggerito:
http://java.sun.com/developer/technicalArticles/J2SE/Desktop/scripting/
http://www.beanshell.org/manual/bshmanual.html#eval()
Dipende molto dal tipo/obiettivo del corso/esercizio.


Purtroppo non mi è molto d'aiuto questa documentazione..speravo che
questo problema si potesse risolvere in maniera più semplice anche
sacrificando l'efficenza del codice..l'importante è superare questo
ostacolo dal quale finora nn so come venirne fuori..qualche altro
consiglio??
Il fatto è che io riesco a valutare il valore booleano delle singole
variabili ma poi non so come seguire la nidificazione delle parentesi e
la priorità che esse hanno rispetto alle altre.
Spero in qualche altro aiuto!
Saluti Luca

 Saluti Luca
usare una struttura ad albero o una pila? (che poi sono quelle che usa 
anche antLR)
sv.

luca ha scritto:

Luca, avevo osservato di "osservare" in particolare il 17.4 
(costruzione) e 17.5 (traversamento) li c'e' l'esempio. Come fa a 
rendere prioritaria la moltiplicazione?
[tu] Tratta le parentesi come se fosse la moltiplicazione. Ogni 
parentesi genera un livello di nidificazione. Utilizzando poi il 
corretto "traversamento" esamini i valori nella corretta gerarchia. 
Inoltre hai comunque il problema che in una serie AND/OR la AND ha 
priorita' rispetto alla OR , esattamente come la moltiplicazione in 
confronto con la addizione.
Poiche' alla base ci sono chiamate ricorsive il codice necessario e' 
"decisamente" contenuto. Tutti? i parser "matematici" utilizzano questa 
struttura.
--
ac

Ciao,
puoi provare cup parser.
http://www2.cs.tum.edu/projects/cup/
ciao
Angelo


Grazie per il consiglio Angelo, ma ho preferito fare diversamente cioè
utilizzare lo Stack per inserire in testa gli operandi e gli operatori
delle espressioni,per esempio se l'espressione è (E1 &(E2 | E3))
inserisco nello Stack E2 poi | poi E3.In tal modo so quali sono gli
operandi e l'operatore per l'espressione più nidificata.
Il mio problema adesso è:come faccio a fare un ciclo sulla stringa
contenente l'espressione in modo tale da inserire ordinatamente nello
Stack gli operandi giusti seguendo le priorità di nidificazione??(tenete
conto che ogni espressione può avere al max 2 operandi cioè non è
ammesso (E1 & E2 | E3)).
Grazie per eventuali risposte.
Saluti,
Luca

 Luca
creare un albero e visitarlo deep first?
sv.


Non c'è possibilità di farlo attraverso cicli?


il suo problema e' creare lo stack (o l'albero), non visitarlo.
Ciao Jack


Esatto Jack, il mio problema è creare lo stack con operandi  ed
operatori già ordinati in modo tale da poterci lavorare semplicemente
scorrendo lo stack dalla cima.
Es.E = (A & (B | C))
Allora lo  Stack deve mettere in cima B poi | poi C poi & poi A, in
maniera che partendo dalla testa potrò estrarre B | C,calcolarne il
risultato e metterlo in testa per poi calcolare il risultato appena
ottenuto & A.
Spero di essere stato chiaro..
Saluti

 Saluti
veramente le operazioni dello stack sono:
push(A)
push(&)
push(B)
push(|)
push(C)
quindi A deve già essere nello stack prima di B.
Lo stack volendo non serve in quanto si può usare quello del sistema 
mentre si fa la visita dell'albero (procedura ricorsiva). Quindi il 
problema si riduce a creare l'albero, che altro non è che la 
rappresentazione statica dell'espressione.
Considerando che:
a- gli operandi sono solo sulle foglie.
b- gli operatori sono solo nei nodi interni.
c- l'albero è binario.
è sufficiente che quando leggi un operando lo metti in una foglia e 
quando leggi l'operatore crei un nodo. Quindi l'espressione (A & (B | 
C)) diventa l'albero:
   &
  / \
A   |
    / \
   B  C
N.B.:
1) Potrebbe essere utile trasformare l'espressione in notazione prefissa 
o postfissa
2) Stando a quanto scritto la parentesi "(" indica la presenza di 
un'operatore e quindi è un comodo marcatore per la creazione del nodo, 
la ")" indica invece la sua fine.
sv.

 Spero di essere stato chiaro..
no, ma fa nulla.
Visto che non vuoi usare un parser generator (come antLR o CUP) ti do'
un hint su come generare l'albero.
Come ha detto sv gli operatori stanno nei nodi e le espressioni nelle
foglie.
Quindi tu prendi la stringa con la tua formula, elimini gli spazi (che
non servono) e inizi a scorrerla cercando gli operatori, quando ne
trovi uno lo metti nel nodo e le due sottostringhe (a destra e a
sinistra dell'operatore) nelle due foglie. E poi reiteri finche' nelle
foglie non ci sono che espressioni.
Lascio a te pensare come gestire la priorita' degli operatori e le
parentesi (hint: potresti dover scorrere le stringhe piu' di una
volta).
Ciao Jack


Grazie per il consiglio,ma alla fine ho risolto usando lo stack e
valutando di volta in volta l'espressione più interna.
Grazie a tutti coloro che mi hanno aiutato!
Saluti Luca.