DerIntCalculator La calcolatrice per integrali e derivate Progetto di Linguaggi e Modelli Computazionali M Prof. Enrico Denti Realizzato da: Gabriella.

Presentazione sul tema: "DerIntCalculator La calcolatrice per integrali e derivate Progetto di Linguaggi e Modelli Computazionali M Prof. Enrico Denti Realizzato da: Gabriella."— Transcript della presentazione:

1 DerIntCalculator La calcolatrice per integrali e derivate Progetto di Linguaggi e Modelli Computazionali M Prof. Enrico Denti Realizzato da: Gabriella Falco

2 Idea di progetto Sviluppo di un linguaggio in grado di riconoscere in maniera semplice ed espressiva i dati necessari per il calcolo degli integrali indefiniti e delle derivate Calcolare e visualizzare i risultati in maniera leggibile a tutti… “infissa”

3 Idea di progetto L'interprete pertanto dovrà: accettare in input le espressioni analizzare lessicalmente e sintatticamente l'input valutare semanticamente le frasi produrre in output il risultato dell'elaborazione Importante: Semplicità d’uso: interfaccia intuitiva e sintassi semplice Complessità del linguaggio ridotta al minimo

4 Strumenti Linguaggio di programmazione: Java Prolog Generazione Parser tuProlog 3.0 JavaCC 5.0 Strumenti di Sviluppo NetBeans IDE 6.8

5 Metodo di realizzazione (1) Java: Visualizza un’interfaccia a forma di calcolatrice per chiedere all’utente l’espressione di input Passa l’espressione al motore prolog configurato con la teoria del caso e lo interroga sottoponendogli l’espressione Recupera il risultato in notazione prefissa e lo passa al parser valutatore, generato con JavaCC Restituisce il risultato all’utente.

6 Metodo di realizzazione (2) tuProlog: Interpreta e valuta l’espressione data e calcola il risultato in accordo alla semantica denotazionale specificata Parser: Analizza l’espressione data in output dal motore prolog e la restituisce in modalità infissa

7 Progetto L’utente sceglie la tipologia di calcolo che vuole effettuare: Normale IntegraleDerivata

8 Integrali intExpr(DT,T):-intTerm(DT,T). intExpr(DE+DT,E+T):-intTerm(DE,E),intExpr(DT,T). intExpr(DE-DT,E-T):-intTerm(DE,E),intExpr(DT,T). intTerm(K*DT,K*T):-number(K),intExpr(DT,T). intTerm(DT*DE,R):-semplifica(DT*DE,DX),intTerm(DX,R). %per parti intTerm(DT*E,T*E-Int):-intFactor(DT,T),dFactor(E,DE),intTerm(T*DE,Int). intTerm(E*DT,E*T-Int):-intFactor(DT,T),dFactor(E,DE),intTerm(T*DE,Int). intTerm(DF,F):-intFactor(DF,F).

9 Integrali intFactor(-DE,-E):-intExpr(DE,E). intFactor([DE],E):-intExpr(DE,E). intFactor(1,x). intFactor(N,N*x):-number(N). intFactor(x,x^2/2). intFactor(x^K,x^N/N):-number(K),N is K+1. intFactor(x^K/Q,x^N/P):- number(K), N is K+1, P is Q*N. intFactor(F^N*DF,F^M/M):- not(N is -1),M is N+1,intFactor(DF,F). intFactor(1/x,log(x)). intFactor(cos(x),sin(x)). intFactor(sin(x),-cos(x)). intFactor(cos(E)*DE,sin(E)):-dFactor(E,DE). intFactor(sin(E)*DE,-cos(E)):-dFactor(E,DE). intFactor(exp(X)*DX,exp(X)):-intExpr(DX,X). intFactor(exp(K*x),exp(x)/K):- number(K). intFactor(exp(x),exp(x)). intFactor(1+(tg(x)^2),tg(x)). intFactor(1+(cotg(x)^2),-cotg(x)). intFactor(a*x,a^x/log(a)).

10 Derivate dExpr(T,DT):-dTerm(T,DT). dExpr(E+T,DE+DT):-dExpr(E,DE),dTerm(T,DT). dExpr(E+T,DE-DT):-dExpr(E,DE),dTerm(T,DT). dTerm(F,DF) :-dFactor(F,DF). dTerm(T*F,DT*F+T*DF) :-dTerm(T,DT),dFactor(F,DF). dTerm(T/F,DT*F-T*DF/F*F) :-dTerm(T,DT),dFactor(F,DF). dFactor(x,1). dFactor(x^K,K*x^N):-number(K),N is K-1. dFactor(N,0) :-number(N). dFactor([E],DE) :-dExpr(E,DE). dFactor(-E,-DE) :-dExpr(E,DE). dFactor(sin(E),DE*cos(E)) :-dExpr(E,DE). dFactor(cos(E),-DE*sin(E)) :-dExpr(E,DE). dFactor(log(E),DE/E):-dExpr(E,DE). dFactor(exp(E),exp(E)*DE) :-dExpr(E,DE).

11 Perché Prolog La grammatica è di tipo 2, perché nella forma: A  a con A  VN, a  (VN+VT) + Il linguaggio è di tipo 3, in quanto non presenta self- embedding La grammatica non è LL(1) poiché serve più di un simbolo per riconoscere le produzioni da scegliere, ma prolog gestisce da sé il non determinismo L’interprete per derivate e integrali è molto più semplice grazie alla semplicità dell’elaborazione simbolica Poche regole Prolog ha un suo scanner e un suo parser Utilissimo il back tracking per riuscire a valutare le diverse tipologie di espressioni

12 Risultato rilevato Prolog, dopo aver valutato l’espressione valutata, ritorna il risultato visualizzandolo in notazione prefissa, non opportuna per la comprensione da parte della maggior parte degli utenti Es: Integrale di a^x=/(^(a,x),log(a)) Derivata di cos(x)=*(-(1),sin(x)) Soluzione: Creare un parser valutatore che consenta di cambiare la notazione in infissa Es: Integrale di a^x=((a^x)/log(a)) Derivata di cos(x)=((1-)*sin(x)) Motivazione: Si poteva pensare di generare un albero e visitarlo in modo da ritornare l’espressione in forma infissa, ma non sempre l’operando corrisponde a un operazione tra due termini… può trattarsi del segno

13 Grammatica :: :: “(” “,” “)” | ”(“ “)”| | | “(” “)” :: | | “(” “)” | In questa forma non sarebbe stata LL(1) :: :: ”(“ | | :: | | :: “,” “)” | “)” :: | “(” “)” :: “+” | “-” | “*” | “/” | “^” :: [“0”- “9”]([“0”- “9”])* :: [“a”- “z”] :: “sin” | “cos” | “log” | “exp” | “tg” | “cotg”

14 Analisi della grammatica La grammatica è di tipo 2 (context free) secondo la classificazione di Chomsky in quanto le produzioni sono vincolate alla forma: A → α con α є (VT U VN)* ed A є VN … tuttavia non sono presenti produzioni con self-embedding A → α1 A α2 con A є VN e α1, α2 є (VN U VT)+ … pertanto il linguaggio è regolare (tipo 3) La grammatica è priva di ε – rules. Il linguaggio quindi non prevede l’uso della stringa vuota, anche perché non ci sarebbe bisogno di invocare il parser

15 Architettura Package GUI: contiene le classi che implementano l’interfaccia grafica e la classe main che inizializza tutto e lancia il programma Package Parser: contiene le classi generate automaticamente da JavaCC che implementano e gestiscono il Parser e che modificano l’input, dato in notazione prefissa nell’output in notazione infissa Package calcolatrice: contiene le classi per l'elaborazione ed il calcolo delle espressioni mediante invocazione delle apposite Teorie Prolog

16 Test, limiti e sviluppi futuri Il programma è stato testato con diverse espressioni: sia per il calcolo di integrali che per il calcolo delle derivate È limitato al calcolo di integrali indefiniti semplici L’integrazione per parti è stata implementata con successo Altri possibili approcci importanti nel calcolo di integrali sono di difficile implementazione (es. sostituzione) È possibile espanderlo arricchendo le regole della teoria prolog È possibile aggiungere delle regole per poter calcolare integrali definiti… bastano delle regole opportune per la valutazione

17 Demo