MatOCAD Logo

Main Page | Class Hierarchy | Class List | Directories | File List | Class Members | File Members | Related Pages

TParserDerivata.cpp

Go to the documentation of this file.
00001 #include "include/Parser/TParserDerivata.h"
00002 #include "include/Parser/FunzioniStringa.h"
00003  /*      Select Case Mid(funzione, 1, 3)
00004         Case "sin"
00005         funzione = "cos(" & Mid(funzione, 4, Len(funzione) - 3) & ")*{" & Mid(funzione, 4, Len(funzione) - 3) & "}"
00006         Case "cos"
00007         funzione = "(-sin(" & Mid(funzione, 4, Len(funzione) - 3) & "))*{" & Mid(funzione, 4, Len(funzione) - 3) & "}"
00008         Case "exp"
00009         funzione = "exp(" & Mid(funzione, 4, Len(funzione) - 3) & ")*{" & Mid(funzione, 4, Len(funzione) - 3) & "}"
00010         Case "tan"
00011         funzione = "(1+(tan(" & Mid(funzione, 4, Len(funzione) - 3) & "))^2)*{" & Mid(funzione, 4, Len(funzione) - 3) & "}"
00012         Case Else
00013 
00014         if (Mid(funzione, 1, 2) = "v[")
00015          funzione = "1";
00016 
00017         if (Mid(funzione, 1, 2) = "ln")
00018          funzione = "1/(" & Mid(funzione, 3, Len(funzione) - 2) & ")*{" & Mid(funzione, 3, Len(funzione) - 2) & "}"
00019 
00020         End Select */
00021 
00022 
00023  void TDerivata::Derivata(char*Risultato,rif* vettore_riferimenti)
00024  {  int i;
00025     int y;
00026 
00027     char funzione_temp[500],risultato_parziale[500];
00028 
00029 
00030  //Alloco la struttura che dovrÓ contenere le derivate parziali
00031     DerivateParziali=(char**)malloc(sizeof(char*)*vettore_riferimenti->numero_scomposizioni);
00032 
00033 
00034    for (i = 0;i<vettore_riferimenti->numero_scomposizioni;i++)
00035     { CalcoloDerivata(risultato_parziale,((vettore_riferimenti+i)->scomposizioni)->scomposizione);
00036       y = 2;
00037      while (y <= (vettore_riferimenti+i)->lunghezza_scomp)
00038      { if (strcmp((((vettore_riferimenti+i)->scomposizioni)+y-1)->scomposizione,"+")==0)
00039         Concatena(risultato_parziale,"+(" );
00040        else
00041         Concatena(risultato_parziale,"-(" );
00042 
00043         CalcoloDerivata(funzione_temp,(((vettore_riferimenti+i)->scomposizioni)+y)->scomposizione);
00044         Concatena(risultato_parziale,funzione_temp);
00045         Concatena(risultato_parziale,")" );
00046 
00047         y = y + 2;
00048      }
00049       *(DerivateParziali+i)=(char*)malloc(sizeof(char)*(Len(risultato_parziale)+1));
00050        strcpy(*(DerivateParziali+i),risultato_parziale);
00051     
00052     }
00053        strcpy(Risultato,risultato_parziale);
00054  }
00055 
00056 
00057 void TDerivata::CalcoloDerivata(char* Soluzione,char* funzioneDerivare)
00058  {
00059   int posizione_elevato;
00060   int posizione_per;
00061   char funzione_temp[500],funzione_temp2[500],funzione_temp3[500];
00062   int n_per=0;
00063   int i;
00064   int posizione_prec;
00065   int posizione_dev;
00066 
00067   //Alloco una stringa temp chiamata funzione lunga 3 volte la funzione da derivare
00068 
00069   // Soluzione=(char*)malloc(sizeof(char)*(Len(funzioneDerivare)*3+1));
00070 
00071    strcpy(Soluzione,"");
00072    posizione_elevato = Instr(1, funzioneDerivare, "^");
00073    int c;
00074   if (posizione_elevato > 0)
00075     c=2;
00076    //  funzione = Mid(funzione, posizione_elevato + 1, Len(funzione) - posizione_elevato) & "*" & Mid(funzione, 1, posizione_elevato) & CInt(Mid(funzione, posizione_elevato + 1, Len(funzione) - posizione_elevato) - 1) & "*{" & Mid(funzione, 1, posizione_elevato - 1) & "}"
00077   else
00078    {  posizione_per = Instr(1, funzioneDerivare, "*");
00079     while (posizione_per > 0)
00080      {n_per++;
00081       posizione_per = Instr(posizione_per + 1, funzioneDerivare, "*");
00082      }
00083      posizione_prec = 1;
00084           //Questo ciclo imbastisce un eventuale derivata di un prodotto
00085          //Ricordo che n_per contiene il numero di per nella funzione
00086         // la derivata di un prodotto ricordiamo xsin(x)= {x}sin(x)+x{sin(x)}
00087     for (i=1;i<=n_per;i++)
00088      { //Cerco un *
00089       posizione_per = Instr(posizione_prec, funzioneDerivare, "*");
00090       Mid(funzione_temp,funzioneDerivare, 1, posizione_prec - 1);
00091       Concatena(Soluzione,funzione_temp);
00092         //i caratteri {} mi identificano che al loro interno vi e' una funzione di cui successivamente
00093        //bisogna calcolare la derivata
00094       Concatena(Soluzione,"{");
00095       Mid(funzione_temp,funzioneDerivare, posizione_prec, posizione_per - posizione_prec);
00096       Concatena(Soluzione,funzione_temp);
00097       Concatena(Soluzione,"}");
00098       Mid(funzione_temp,funzioneDerivare, posizione_per, Len(funzioneDerivare) - posizione_per + 1);
00099       Concatena(Soluzione,funzione_temp);
00100       Concatena(Soluzione,"+");
00101       posizione_prec = posizione_per + 1;
00102      }
00103       Mid(funzione_temp,funzioneDerivare, 1, posizione_per);
00104       Concatena(Soluzione,funzione_temp);
00105       Concatena(Soluzione,"{");
00106       Mid(funzione_temp,funzioneDerivare, posizione_prec, Len(funzioneDerivare) - posizione_prec + 1);
00107       Concatena(Soluzione,funzione_temp);
00108       Concatena(Soluzione,"}");
00109   }
00110       posizione_dev = Instr(1, Soluzione, "{");
00111   while (posizione_dev > 0)
00112    {
00113      funzione_temp2[0]='\0';
00114 
00115      Mid(funzione_temp,Soluzione, 1, posizione_dev - 1);
00116      Concatena(funzione_temp2,funzione_temp);
00117      Mid(funzione_temp,Soluzione, posizione_dev + 1, Instr(1, Soluzione, "}") - posizione_dev - 1);
00118      DFondamentale(funzione_temp3,funzione_temp);
00119      Concatena(funzione_temp2,funzione_temp3);
00120      Mid(funzione_temp,Soluzione, Instr(1,Soluzione, "}") + 1, Len(Soluzione) - Instr(1,Soluzione, "}"));
00121      Concatena(funzione_temp2,funzione_temp);
00122 
00123    //funzione = Mid(funzione, 1, posizione_dev - 1) &  & Mid(funzione, InStr(1, funzione, "}") + 1, Len(funzione) - InStr(1, funzione, "}"))
00124     strcpy(Soluzione,funzione_temp2);
00125     posizione_dev = Instr(1, Soluzione, "{");
00126    }
00127 
00128 
00129 
00130 }
00131 
00132 void TDerivata::DFondamentale(char* Soluzione,char* funzione)
00133 {
00134   int posizione_diviso;
00135   char* denominatore;
00136   char* numeratore;
00137   char funzione_temp[500];
00138   int lunghezza;
00139   posizione_diviso = Instr(1, funzione, "/");
00140 
00141 if (posizione_diviso > 0)
00142  {  numeratore=(char*)malloc(sizeof(char)*(posizione_diviso));
00143     denominatore=(char*)malloc(sizeof(char)*(Len(funzione) - posizione_diviso+1));
00144     Mid(numeratore,funzione, 1, posizione_diviso - 1);
00145     Mid(denominatore,funzione, posizione_diviso + 1, Len(funzione) - posizione_diviso);
00146    // funzione = "({" & numeratore & "}*(" & denominatore & ")-(" & numeratore & ")*{" & denominatore & "})/(" & denominatore & ")^2"
00147     strcpy(Soluzione,"({");
00148     Concatena(Soluzione,numeratore);
00149     Concatena(Soluzione,"}*(");
00150     Concatena(Soluzione,denominatore);
00151     Concatena(Soluzione,")-(");
00152     Concatena(Soluzione,numeratore);
00153     Concatena(Soluzione,")*{");
00154     Concatena(Soluzione,denominatore);
00155     Concatena(Soluzione,"})/(");
00156     Concatena(Soluzione,denominatore);
00157     Concatena(Soluzione,")^2");
00158     free(numeratore);
00159     free(denominatore);
00160  }else
00161  {  lunghezza = Len(funzione);
00162   if (Isnumeric(funzione)==0)
00163    { if (lunghezza >= 3)
00164       {
00165          if ((funzione[0]=='S')&&(funzione[1]=='i')&&(funzione[2]=='n'))
00166          {
00167           strcpy(Soluzione,"Cos(");
00168           Mid(funzione_temp,funzione, 4, Len(funzione) - 3);
00169           Concatena(Soluzione,funzione_temp);
00170           Concatena(Soluzione,")*{");
00171           Concatena(Soluzione,funzione_temp);
00172           Concatena(Soluzione,"}");
00173          }
00174 
00175          if ((funzione[0]=='C')&&(funzione[1]=='o')&&(funzione[2]=='s'))
00176          {
00177           strcpy(Soluzione,"(-Sin(");
00178           Mid(funzione_temp,funzione, 4, Len(funzione) - 3);
00179           Concatena(Soluzione,funzione_temp);
00180           Concatena(Soluzione,"))*{");
00181           Concatena(Soluzione,funzione_temp);
00182           Concatena(Soluzione,"}");
00183          }
00184 
00185          if ((funzione[0]=='E')&&(funzione[1]=='x')&&(funzione[2]=='p'))
00186          {
00187           strcpy(Soluzione,"Exp(");
00188           Mid(funzione_temp,funzione, 4, Len(funzione) - 3);
00189           Concatena(Soluzione,funzione_temp);
00190           Concatena(Soluzione,")*{");
00191           Concatena(Soluzione,funzione_temp);
00192           Concatena(Soluzione,"}");
00193          }
00194 
00195          if ((funzione[0]=='T')&&(funzione[1]=='a')&&(funzione[2]=='n'))
00196          {
00197            strcpy(Soluzione,"(1+(Tan(");
00198            Mid(funzione_temp,funzione, 4, Len(funzione) - 3);
00199            Concatena(Soluzione,funzione_temp);
00200            Concatena(Soluzione,"))^2)*{");
00201            Concatena(Soluzione,funzione_temp);
00202            Concatena(Soluzione,"}");
00203          }
00204 
00205 
00206          if (funzione[0]=='[')
00207          {
00208           strcpy(Soluzione,"1");
00209          }
00210 
00211          if ((funzione[0]=='L')&&(funzione[1]=='n'))
00212          {
00213            strcpy(Soluzione,"1/(");
00214            Mid(funzione_temp,funzione, 3, Len(funzione) - 2);
00215            Concatena(Soluzione,funzione_temp);
00216            Concatena(Soluzione,")*{");
00217            Concatena(Soluzione,funzione_temp);
00218            Concatena(Soluzione,"}");
00219          }
00220 
00221       }else
00222       { strcpy(Soluzione,"(");
00223         Concatena(Soluzione,*(DerivateParziali+funzione[0]-97));
00224         Concatena(Soluzione,")");
00225       }
00226        // funzione = "(" & derivate(Asc(funzione) - 96) & ")"
00227    }
00228 
00229    else
00230     strcpy(Soluzione,"0");
00231  }
00232 //DFondamentale = funzione
00233 }
00234 /*
00235 Public Function Semplifica(ByVal funzione_inizial As String) As String
00236  Dim posizione_variabile As Integer
00237  Dim posizione_zero As String
00238  Dim variabile As String
00239  Dim n_parentesi As Integer
00240  Dim estremo_inf As Integer
00241  Dim estremo_sup As Integer
00242  Dim carattere As String
00243  Dim i As Integer
00244  Dim y As Integer
00245  Dim flag As Integer
00246  Dim num_temp1 As Integer
00247  Dim valore As Double
00248  Dim valori(10) As Double
00249  Dim funzione_iniziale As String
00250  funzione_iniziale = funzione_inizial
00251    i = 1
00252  While (i < Len(funzione_iniziale))
00253    If (Mid(funzione_iniziale, i, 1) >= "a") And (Mid(funzione_iniziale, i, 1) <= "z") Then
00254     If (i < Len(funzione_iniziale)) Then
00255      If (Mid(funzione_iniziale, i + 1, 1) <> "(") And (Mid(funzione_iniziale, i + 1, 1) <> "[") And (Mid(funzione_iniziale, i + 1, 1) <> "]") And ((Mid(funzione_iniziale, i + 1, 1) < "a") Or (Mid(funzione_iniziale, i + 1, 1) > "z")) Then
00256       funzione_iniziale = Mid(funzione_iniziale, 1, i - 1) & "(" & ricomponi(vettore_riferimenti(Asc(Mid(funzione_iniziale, i, 1)) - 96).descrizione) & ")" & Mid(funzione_iniziale, i + 1, Len(funzione_iniziale) - i)
00257      End If
00258     End If
00259    End If
00260    i = i + 1
00261  Wend
00262     funzione_iniziale = ricomponi(funzione_iniziale)
00263     posizione_variabile = 1
00264     posizione_variabile = InStr(1, funzione_iniziale, "v[")
00265    While (posizione_variabile > 0)
00266      variabile = Mid(funzione_iniziale, posizione_variabile + 2, InStr(posizione_variabile, funzione_iniziale, "]") - posizione_variabile - 2)
00267      funzione_iniziale = Mid(funzione_iniziale, 1, posizione_variabile - 1) + variabile + Mid(funzione_iniziale, InStr(posizione_variabile, funzione_iniziale, "]") + 1, Len(funzione_iniziale) - InStr(posizione_variabile, funzione_iniziale, "]"))
00268      posizione_variabile = InStr(1, funzione_iniziale, "v[")
00269    Wend
00270 '     i = 1
00271 '   While i < Len(funzione_iniziale)
00272 '    If (IsNumeric(Mid(funzione_iniziale, i, 1))) Or (Mid(funzione_iniziale, i, 1) = "-") Then
00273 '      y = i + 1
00274 '     While (IsNumeric(Mid(funzione_iniziale, y, 1))) Or (Mid(funzione_iniziale, y, 1) = "*") Or (Mid(funzione_iniziale, y, 1) = "-")
00275 '      y = y + 1
00276 '     Wend
00277 '     If Not IsNumeric(Mid(funzione_iniziale, y - 1, 1)) Then
00278 '      y = y - 1
00279 '     End If
00280 '      valore = elabora(Mid(funzione_iniziale, i, y - i), valori)
00281 '      funzione_iniziale = Mid(funzione_iniziale, 1, i - 1) & CStr(valore) & Mid(funzione_iniziale, y, Len(funzione_iniziale) - y + 1)
00282 '      i = i + Len(CStr(valore))
00283 '     End If
00284 '     If ((Mid(funzione_iniziale, i, 1) = "/") Or (Mid(funzione_iniziale, i, 1) = "^")) And (IsNumeric(Mid(funzione_iniziale, i + 1, 1))) Then
00285 '      While (IsNumeric(Mid(funzione_iniziale, i, 1)))
00286 '       i = i + 1
00287 '      Wend
00288 '       i = i + 1
00289 '     End If
00290 '       i = i + 1
00291 '   Wend
00292 
00293 
00294      i = InStr(1, funzione_iniziale, "0")
00295 '   While i > 0
00296 '      flag = 1
00297 '     If (i > 1) Then
00298 '      If (IsNumeric(Mid(funzione_iniziale, i - 1, 1))) Or (Mid(funzione_iniziale, i - 1, 1) = "^") Then
00299 '       flag = 0
00300 '      End If
00301 '     End If
00302 '     If (Not IsNumeric(Mid(funzione_iniziale, i + 1, 1))) And (flag = 1) Then
00303 '          posizione_zero = i
00304 '       While (carattere <> "+") And (carattere <> "-") And (i > 1)
00305 '          i = i - 1
00306 '          carattere = Mid(funzione_iniziale, i, 1)
00307 '         If (carattere = "(") Then
00308 '          n_parentesi = n_parentesi + 1
00309 '         End If
00310 '         If (carattere = ")") Then
00311 '          n_parentesi = n_parentesi - 1
00312 '         End If
00313 '        Wend
00314 '          estremo_inf = i - 1
00315 '          i = posizione_zero
00316 '          carattere = "0"
00317 '       While ((n_parentesi <> 0) Or ((carattere <> "+") And (carattere <> "-"))) And (i < Len(funzione_iniziale))
00318 '          i = i + 1
00319 '          carattere = Mid(funzione_iniziale, i, 1)
00320 '         If (carattere = "(") Then
00321 '          n_parentesi = n_parentesi + 1
00322 '         End If
00323 '         If (carattere = ")") Then
00324 '          n_parentesi = n_parentesi - 1
00325 '         End If
00326 '       Wend
00327 '          estremo_sup = i
00328 '          funzione_iniziale = Mid(funzione_iniziale, 1, estremo_inf) & Mid(funzione_iniziale, estremo_sup, Len(funzione_iniziale) - estremo_sup + 1)
00329 '     End If
00330 '        i = InStr(1, funzione_iniziale, "0")
00331 '  Wend
00332   i = InStr(1, funzione_iniziale, "()")
00333  While (i > 0)
00334  If (i > 1) Then
00335   funzione_iniziale = Mid(funzione_iniziale, 1, i - 2) & Mid(funzione_iniziale, i + 2, Len(funzione_iniziale) - i - 1)
00336  Else
00337   funzione_iniziale = Mid(funzione_iniziale, 1, i - 1) & Mid(funzione_iniziale, i + 2, Len(funzione_iniziale) - i - 1)
00338 
00339  End If
00340   i = InStr(i + 1, funzione_iniziale, "()")
00341 
00342  Wend
00343  If (funzione_iniziale = "") Then
00344   funzione_iniziale = "0"
00345  End If
00346   Semplifica = funzione_iniziale
00347 End Function
00348 Private Function ricomponi(funzione As String) As String
00349  Dim i As Integer
00350  Dim y As Integer
00351  i = InStr(1, funzione, "exp")
00352 While (i > 0)
00353  If (Mid(funzione, i + 3, 1) <> "(") Then
00354      y = i + 3
00355   If (IsNumeric(Mid(funzione, i + 3, 1))) Then
00356    While (IsNumeric(Mid(funzione, y, 1)))
00357     y = y + 1
00358    Wend
00359   Else
00360    If (Mid(funzione, i + 3, 2) = "v[") Then
00361     y = InStr(i + 1, funzione, "]")
00362    End If
00363   End If
00364    funzione = Mid(funzione, 1, i + 2) & "(" & Mid(funzione, i + 3, y - i - 2) & ")" & Mid(funzione, y + 1, Len(funzione) - y)
00365  End If
00366    i = InStr(i + 1, funzione, "exp")
00367 Wend
00368 
00369  i = InStr(1, funzione, "sin")
00370 While (i > 0)
00371  If (Mid(funzione, i + 3, 1) <> "(") Then
00372     y = i + 3
00373   If (IsNumeric(Mid(funzione, i + 3, 1))) Then
00374    While (IsNumeric(Mid(funzione, y, 1)))
00375     y = y + 1
00376    Wend
00377   Else
00378    If (Mid(funzione, i + 3, 2) = "v[") Then
00379     y = InStr(i + 1, funzione, "]")
00380    End If
00381   End If
00382     funzione = Mid(funzione, 1, i + 2) & "(" & Mid(funzione, i + 3, y - i - 2) & ")" & Mid(funzione, y + 1, Len(funzione) - y)
00383  End If
00384     i = InStr(i + 1, funzione, "sin")
00385 Wend
00386 
00387  i = InStr(1, funzione, "cos")
00388 While (i > 0)
00389  If (Mid(funzione, i + 3, 1) <> "(") Then
00390    y = i + 3
00391   If (IsNumeric(Mid(funzione, i + 3, 1))) Then
00392    While (IsNumeric(Mid(funzione, y, 1)))
00393     y = y + 1
00394    Wend
00395   Else
00396    If (Mid(funzione, i + 3, 2) = "v[") Then
00397     y = InStr(i + 1, funzione, "]")
00398    End If
00399   End If
00400     funzione = Mid(funzione, 1, i + 2) & "(" & Mid(funzione, i + 3, y - i - 2) & ")" & Mid(funzione, y + 1, Len(funzione) - y)
00401  End If
00402     i = InStr(i + 1, funzione, "cos")
00403 Wend
00404 
00405  i = InStr(1, funzione, "tan")
00406 While (i > 0)
00407  If (Mid(funzione, i + 3, 1) <> "(") Then
00408     y = i + 3
00409   If (IsNumeric(Mid(funzione, i + 3, 1))) Then
00410    While (IsNumeric(Mid(funzione, y, 1)))
00411     y = y + 1
00412    Wend
00413   Else
00414    If (Mid(funzione, i + 3, 2) = "v[") Then
00415     y = InStr(i + 1, funzione, "]")
00416    End If
00417   End If
00418    funzione = Mid(funzione, 1, i + 2) & "(" & Mid(funzione, i + 3, y - i - 2) & ")" & Mid(funzione, y + 1, Len(funzione) - y)
00419  End If
00420    i = InStr(i + 1, funzione, "tan")
00421 Wend
00422 
00423  i = InStr(1, funzione, "ln")
00424 While (i > 0)
00425  If (Mid(funzione, i + 2, 1) <> "(") Then
00426     y = i + 2
00427   If (IsNumeric(Mid(funzione, i + 2, 1))) Then
00428    While (IsNumeric(Mid(funzione, y, 1)))
00429     y = y + 1
00430    Wend
00431   Else
00432    If (Mid(funzione, i + 2, 2) = "v[") Then
00433     y = InStr(i + 1, funzione, "]")
00434    End If
00435   End If
00436    funzione = Mid(funzione, 1, i + 1) & "(" & Mid(funzione, i + 2, y - i - 1) & ")" & Mid(funzione, y + 1, Len(funzione) - y)
00437  End If
00438    i = InStr(i + 1, funzione, "ln")
00439 
00440 Wend
00441  ricomponi = funzione
00442 
00443 End Function*/

 

SourceForge Logo