1 / 17

DerIntCalculator

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

glen
Download Presentation

DerIntCalculator

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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: Integrale Derivata Normale

  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acon 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 <S>:: <E> <E>:: <Op> “(” <Left> “,” <Right> “)” | <Op>”(“<Left> “)”| < Num>|<Cost>|<Var> “(” <E> “)” <Left>:: <Num> | <Cost> | <Var> “(” <E> “)” | <E> <Right >:: <Num> | <Cost> | <Var> “(” <E> “)” | <E> In questa forma non sarebbe stata LL(1) <S>:: <E> <E>:: <Op> ”(“ <Comp> <T> | <Cost> | <C> <Comp>:: <Cost> |<C> | <E> • <T>:: “,” <Comp> “)” | “)” • <C>:: <Num> | <Var> “(” <E> “)” <Op>:: “+” | “-” | “*” | “/” | “^” <Num>:: [“0”- “9”]([“0”- “9”])* <Cost>:: [“a”- “z”] <Var>:: “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

More Related