TParserValore.cpp

Go to the documentation of this file.

#include "../../include/Parser/TParserValore.h"
#include <math.h>
int FlagErrore;
#ifdef __WXWIN__
int _matherr( struct _exception *except )
#endif
#ifdef __WXGTK__
int _matherr( struct __exception *except )
#endif
{
  except->retval=0;
  FlagErrore=1;
  return 1;
  }
//**************************************************************************
/*
  * Nome funzione:     CalcolaValore
  * Parametri:         vettore_riferimenti:  struttura contenente  la funzione scomposta
                       valori: vettore di double contenente i valori da sostituire alle
                               variabili della funzione
                      *errore: puntatore a int per l'evidenziazione di un eventuale errore
                               nel calcolo

  * Valori di ritorno: un valore double
  * Descrizione: questa funzione ha il compito di dirigere le operazioni per il calcolo del
                 valore utilizzando la struttura dati e richiamando altre funzioni al suo
                 interno



*/
//**************************************************************************

double TParserValore::CalcolaValore(rif*vettore_rif, double valor[] ,int* errore)
 {
  int conta=0;
  double temp;
  int i;
  double valore;


  int numero_scomposizioni=vettore_rif->numero_scomposizioni;
  vettore_riferimenti=vettore_rif;
  valori=valor;
  FlagErrore=0;
  *errore=0;

try
{  while ((conta <numero_scomposizioni)&&(FlagErrore == 0))
   {  temp = Elabora(((vettore_riferimenti+conta)->scomposizioni)) ;
      i = 2;
     while ((i <= (vettore_riferimenti+conta)->lunghezza_scomp)&&(FlagErrore == 0))
      {if (**((((vettore_riferimenti+conta)->scomposizioni)+i-1)->scomposizione)=='+')
        temp = temp + Elabora((((vettore_riferimenti+conta)->scomposizioni)+i));
       else
         temp = temp - Elabora((((vettore_riferimenti+conta)->scomposizioni)+i));

         i = i + 2;
      }
          (vettore_riferimenti+conta)->valore = temp;
          conta++;
   }
  valore = (vettore_riferimenti+numero_scomposizioni-1)->valore;
}catch(...)
{
 *errore=1;
  return(0);
}
 if (FlagErrore == 1)
  {*errore = 1;
    return(0);
  }
  return(valore);
}

//**************************************************************************
/*
  * Nome funzione:     Elabora
  * Parametri:         funzione: stringa che contiene una singola cella della struttura
                                 dati
                       valori:   vettore di double contenente i valori da sostituire alle
                                 variabili della funzione
                       vettore_riferimenti:  struttura contenente  la funzione scomposta

  * Valori di ritorno: un valore double
  * Descrizione: questa funzione ha il compito di calcolare, attraverso i valori numerici
                 passati come parametro,il risultato di una singola casella della struttura
                 dati, questo risultato verrà utilizzato dalla funzione CalcolaValore per
                 l'obbiettivo finale



*/
//**************************************************************************
double TParserValore::Elabora(scompos* scomposizione)
{ int i=1;
  char** matrice=(*scomposizione).scomposizione;
  double valore=Traduci(*matrice);

  while (i <(*scomposizione).n_colonne-1)
   {
      switch(**(matrice+i))
       { case '*':
          valore*=Traduci(*(matrice+i+1));
         break;
         case '/':
          valore/=Traduci(*(matrice+i+1));
         break;
         default:
          valore=pow(valore,Traduci(*(matrice+i+1)));
       }
          i+=2;
   }

 return(valore);

}



//**************************************************************************
/*
  * Nome funzione:     Traduci
  * Parametri:         funzione: stringa che contiene solo una parte di una cella della
                                 struttura dati esente da operatori aritmentici
                       vettore_riferimenti:  struttura contenente  la funzione scomposta
                       valori:   vettore di double contenente i valori da sostituire alle
                                 variabili della funzione


  * Valori di ritorno: un valore double
  * Descrizione: questa funzione ha il compito di identificare funzioni matematiche note
                 come sin,cos,ecc scomposte dalla funzione Elabora e calcolarne il valore
                 numerico attraverso i parametri


*/
//**************************************************************************

double TParserValore::Traduci(char* funzione)
 {

   char funzione_temp2[20];

 if (Isnumeric(funzione)==0)
  { if (funzione[1] == '\0')// Se len(funzione)=1
        return((vettore_riferimenti+funzione[0] - 97)->valore);
     else
     { if((funzione[0]=='S')&&(funzione[1]=='i')&&(funzione[2]=='n'))
          { if(funzione[3]=='[')
                return(sin(valori[funzione[4]-48]));//sin(valori(indicevariabile))
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(sin(atof(funzione_temp2)));
               else
                 return(sin((vettore_riferimenti+funzione[3] - 97)->valore));
              }
           }
        if((funzione[0]=='C')&&(funzione[1]=='o')&&(funzione[2]=='s'))
          { if(funzione[3]=='[')
                return(cos(valori[funzione[4]-48]));
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(cos(atof(funzione_temp2)));
               else
                return(cos((vettore_riferimenti+funzione[3] - 97)->valore));

             }
           }
        if((funzione[0]=='T')&&(funzione[1]=='a')&&(funzione[2]=='n'))
         {  if(funzione[3]=='[')
              return(tan(valori[funzione[4]-48]));
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(tan(atof(funzione_temp2)));
               else
                return(tan((vettore_riferimenti+funzione[3] - 97)->valore));

             }
         }
        if((funzione[0]=='L')&&(funzione[1]=='o')&&(funzione[2]=='g'))
         {  if(funzione[3]=='[')
             return(log10(valori[funzione[4]-48]));
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(log10(atof(funzione_temp2)));
               else
                return(log10((vettore_riferimenti+funzione[3] - 97)->valore));
              }
          }

        if((funzione[0]=='E')&&(funzione[1]=='x')&&(funzione[2]=='p'))
         {  if(funzione[3]=='[')
             return(exp(valori[funzione[4]-48]));
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(exp(atof(funzione_temp2)));
               else
                 return(exp((vettore_riferimenti+funzione[3] - 97)->valore));

             }
         }
         if((funzione[0]=='A')&&(funzione[1]=='b')&&(funzione[2]=='s'))
          { if(funzione[3]=='[')
             return(fabs(valori[funzione[4]-48]));
            else
             {  Mid(funzione_temp2,funzione, 4, Len(funzione) - 3);
               if(Isnumeric(funzione_temp2))
                return(fabs(atof(funzione_temp2)));
               else
                 return(fabs((vettore_riferimenti+funzione[3] - 97)->valore));

             }
           }
         if((funzione[0]=='L')&&(funzione[1]=='n'))
          { if(funzione[2]=='[')
             return(log(valori[funzione[3]-48]));
            else
             {  Mid(funzione_temp2,funzione, 3, Len(funzione) - 2);
               if(Isnumeric(funzione_temp2))
                return(log(atof(funzione_temp2)));
               else
                 return(log((vettore_riferimenti+funzione[2] - 97)->valore));

             }
           }else
             return(valori[funzione[1]-48]); //SI TRATTA DELLA VARIABILE
       }


  }else
    return(atof(funzione));
}