[java] classe espressione con variabili

[coocooche]

Ciao,
Sto cercando di trovare un thread già aperto al riguardo pero non trovo nulla!
Devo fare una classe ESPRESSIONE che mi permette di rappresentare le espressione con le variabile tipo 2x+3, 3x+sinx/4 ecc ecc.....poi in questa classe devo implementare un po' di metodi tipo la derivata. ti fa pensare ad un CAS semplificato ma non mi serve di fare il parser del input e poi elaborarlo ecc ec.....una semplice struttura dati che mi permette di rappresentare le espressioni......

mi date qualche dritta please?!

Grazie anticipatamente
Gentjan

[Pastore12]

Il fatto è che anche una stringa è una struttura dati adatta rappresentare una espressione matematica...

Dici che non ti serve un parser, ma se vuoi qualcosa di più complesso di una String, mi sembra che invece sia necessario.

Ad esempio, sinx è una variabile o una funzione sin della variabile x? Se devi discriminare una cosa simile ti serve qualcosa che assomiglia molto a un parser...

Riguardo alla struttura dati adatta, credo che sia una cosa altrettanto complicata quanto studiata.. hai provato a fare qualche ricerca con google?

...

A quanto vedo Wikipedia concorda con me: http://it.wikipedia.org/wiki/Parsing

Riguardo alla struttura dati, potrebbe tornarti utile un albero. Ad ogni nodo è associata un operatore e i suoi figli (che possono essere 1 o 2) sono ancora due espressioni oppure 2 variabili. Credo.. ok.. questa era la parte banale.. la parte difficile è il parsing.. io ti posso solo augurare di trovare qualcosa di utile in wikipedia o da google.

...

Forse può tornarti utile anche questo articolo per php: espressioni matematiche in php la pratica

[coocooche]

Ciao,
e' ufficiale:sono senza internet a casa...devo andare nei laboratori per avere accesso a internet
Intanto Pastore2 ti ringrazio per la risposta!
Dunque, dopo un esame ho ripreso a fare questo proggettino...posto in seguito la traccia:

Deve essere realizzata:
1) una classe Espressione che permette di rappresentare le espressioni con variabili, come ad esempio sin2x-ylnx.
Implementare in Espressione:
1-1) un metodo Semplifica che tiene conto dello 0 come elemento neutro della somma e come elemento che annulla un prodotto, e dell’1 come elemento neutro del prodotto. Ad esempio, x*0+0+3*1*x diviene 3*x.
1-2) un metodo Derivata che presa in input una stringa x, restituisce la derivata prima dell’espressione rispetto alla variabile indicata dalla stringa x. (L’espressione restituita deve essere “semplificata” con il metodo Semplifica)
1-3) un metodo che permetta di rappresentare come stringa una espressione.

No albero binario, stack o qualsiasi altra struttura dati...
l'idea e' di creare una classe (astratta) "Espressione" che definisce l'interfaccia del espressione con i suoi metodi (Semplifica(),Derivata(),toString())....questa fara' da classe "genitrice" e poi implementare le classi "figlie" derivate da questa(somma,sottrazione,dividi,moltiplica,log,ln, cos,sin ecc (piu' ne metti meglio e'))....
Bene, detto tutto si passa alla pratica:come faccio?!

abstract class Espressione{
   // Costruttore 
   public Espressione(){
   }      
   public void Semplifica();   
   public String Derivata();   
   public void Stampa(); 
}

....

[alde90]

Ho avuto lo stesso problema, io ho risolto utilizzando una struttura classi usando il design pattern Composite:

Una espressione può essere semplice o composta, e quella composta è un'insieme di più espressioni unite tra loro, anch'esse semplici o composte. Si vede che è ricorsiva, però è abbastanza semplice implementarla una volta progettata bene la struttura delle classi.

Per fare il parsing, io ho diviso prima per gli operatori di minore importanza (+ e -) poi via via fino ad arrivare alla potenza, che ha la precedenza. Con il metodo calcola, poi, calcolava la funzione in un determinato punti. Due lunghi pomeriggi spesi ma ne è valsa la pena

Comunque il problema è simile per te a quanto ho capito: dividere l'espressione nei vari pezzi per poi poterli processare (derivata).

Prova a pensare a questo approccio, il parser ricorsivo è quello più intuitivo

[coocooche]

devo fare una cosa molto piu' semplice di quello che tu cerchi di spiegarmi....niente input da analizzare e quindi niente parser....semplicemente devo pensare a come
[CODE]
Espressione.java

abstract class Espressione{
// Costruttore
public Espressione(){
}
public void Semplifica();
public String Derivata();
public void Stampa();
}
[CODE]

poi fare:
[CODE]
Sum.java

abstract class Sum extends Espressione{
double op1;
double op2;
// Costruttore
public Sum(double e1, double e2){
...
}
public void Semplifica(){
...
}

public String Derivata(){
...
}
public void Stampa(){
...
}
}
[CODE]
e cosi via per log, ln,sin,cos,costante,ecc...

Cmq ho un po' le idea confuse....stasera vedo per bene un po' tutto, chiarisco le idee e posto per bene...

Grazie del attenzione a tutti
Buona serata
Ciao

[coocooche]

Ciao ragazzi,
penso di aver già preso una strada per risolvere questo problema:
prima di tutto ho la classe abstract "Espressione" con i metodi "semplifica","derivata","espressioneToString"

abstract public class Espressione {
        static Espressione semplifica(Espressione e){
                    ....//ancora da implementare
        }
        static void derivata(){
                    ...//ancora da implementare
        }
        static String espressioneToString(Espressione e) {
          if(e instanceof Variabile){ 
               return ((Variabile)e).variabile();
          }
          else 
          if(e instanceof Negazione){
               return "-" + espressioneToString(((Negazione)e).operando());
          }
          else 
          if(e instanceof Somma){
              return espressioneToString(((Somma)e).operando1()) +
              " + " + espressioneToString(((Somma)e).operando2());
          }
     
         ....ecc.
    

         if(e instanceof Costante){
            double c = ((Costante)e).getValore(); 
            String str = new String(String.valueOf(c));
            return (str);
         }
       return (" ");
      }

}

poi tutte le altre classi (una per ogni operazione tra espressioni) in numero limitato:
"Somma","Sottrazione","Divisione","Moltiplicazione ","Negazione","Variabile","Costante","Seno","Cosen o","Tangente","Esponente" e "Ln".
poi sulla faccio una cosa del genere:

void main(){
  ...
  
   //test stampa espressione: sin(2^x-y)/(ln(x))
   Espressione myExp = new Divisione(new Seno(new Sottrazione(new Esponente(new Costante(2.0), new Variabile("x")),new Variabile("y"))),new Ln(new Variabile("x")) ); 
   System.out.println("\nStampa espressione: "+ Espressione.espressioneToString(myExp));
    
   /****************OUTPUT************************
    * Stampa espressione: sin(2.0^x - y) / ln(x)
    *
    **********************************************

mi serve da implementare:
"semplifica" e "derivata"
idee?!