Je ne l'avais pas posté ici, car il n'est pas encore paufiné... mais cela pourra surement t'aider. (je l'ai fait en notation polonaise, mais pas inverse...)
#include <iostream>
#include <math.h>
using namespace std;
////////////////////////////////////////////////////////////////////////////////
class ElemListDouble
{
public:
ElemListDouble(double elem = 0, ElemListDouble* ptr = NULL)
{
d = elem;
p = ptr;
}
double d;
ElemListDouble* p;
};
////////////////////////////////////////////////////////////////////////////////
class ElemListChar
{
public:
ElemListChar(char elem = 0, ElemListChar* ptr = NULL)
{
c = elem;
p = ptr;
}
char c;
ElemListChar* p;
};
////////////////////////////////////////////////////////////////////////////////
class fonction
{
public:
//Constructeur. Reçoit une commande et sa longueur.
//Il va transformer la commande en notation polonaise dans la liste
//dont la tête est pFonction liée à pValeurs.
fonction(char* cCommande, int nDimCommande /* doit etre < 512*/);
//Destructeur. Détruit les listes pFonction et pValeurs.
~fonction();
//Fais le travail du constructeur si on souhaite modifier la commande.
void modif(char* cCommande, int nDimCommande /*doit etre < 512*/);
//Reçoit une valeur d'abscisse dX et renvoie la valeur de la fonction en dX.
//Reçoit ausssi par adresse une variable bool mise à 0 si on est en non-réel
double valeur(double dX, bool& bOk);
//Stocke la chaine de façon "vulgaire", c-à-d sous la forme de départ.
// //devra être supprimée une fois transformée...
char cVulg[512];
protected:
//Tête de liste de la fonction sous sa forme polonaise.
ElemListChar* pFonction;
//Tête de liste des valeurs associées.
ElemListDouble* pValeurs;
//Pointeur "de travail"
ElemListChar* p;
//Pointeur "de travail"
ElemListDouble* q;
//Stockage de la valeur en abscisse lors du calcul de la valeur en ordonnée.
double dVarX;
//Reste à true tant qu'on travail dans les réels.
bool bValReel;
//Lecture récursive de la chaine polonaise.
//lis à partir du pointeur p.
double LectTransf(void);
//Transformation récursive de la forme vulgaire à la forme polonaise.
//transforme ce qui est entre les bornes.
void transf(int nDebut, int nFin);
//Lecture récursive de la chaine vulgaire.
//renvoie la valeur de ce qu'il y a entre les bornes.
double LectVulg(int nDebut,int nFin);
};
///////////////////////////////////////////////////////////////////////////////
int main()
{
char cCommande[512];
double dX;
double dValEnX;
bool bOk;
int Nbr;
cout << "Entrez une fonction :" << endl;
cin >> cCommande;
fonction f(cCommande,strlen(cCommande));
do
{
cout << "Entrez un x (187 pour quitter)" << endl;
cin >> dX;
cout << "Calculer combien de fois ?" << endl;
cin >> Nbr;
for (int i=0;i<Nbr;i++)
dValEnX = f.valeur(dX,bOk);
if (bOk)
cout << "f(" << dX << ") = " << dValEnX << endl;
else
cout << "Valeur non reelle..." << endl;
system("pause");
} while (dX != 187);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//Constructeur.
fonction::fonction(char* cCommande, int nDimCommande /*doit etre < 512*/)
{
//Place la commande recue par adresse dans le tableau cVulg[512]
for (int i = 0; i < nDimCommande; i++)
cVulg[i] = cCommande[i];
//Pour des raisons ultérieurs, le dernier caractère doit être \0
cVulg[nDimCommande] = 0;
//Initialise les pointeurs de tête de la version polonaise de la commande
pFonction = new ElemListChar;
pValeurs = new ElemListDouble;
//Initialisation des variable de travail p et q
p = pFonction;
q = pValeurs;
//Transformation de la commande en notation polonaise
transf(0,nDimCommande-1);
}
////////////////////////////////////////////////////////////////////////////////
//Destructeur.
fonction::~fonction()
{
//Supprime la chaine pointée par pFonction.
p = pFonction;
while (p->p)
{
ElemListChar* t = p->p;
delete p;
p = t;
}
delete p;
//Supprime la chaine pointée par pValeurs
q = pValeurs;
while (q->p)
{
ElemListDouble* t = q->p;
delete q;
q = t;
}
delete q;
}
////////////////////////////////////////////////////////////////////////////////
//Fait le même travail que le destructeur et le constructeur. (voir plus haut)
void fonction::modif(char* cCommande, int nDimCommande)
{
if (nDimCommande > 511)
nDimCommande = 511;
for (int i = 0; i < nDimCommande; i++)
cVulg[i] = cCommande[i];
cVulg[nDimCommande] = 0;
p = pFonction;
while (p->p)
{
ElemListChar* t = p->p;
delete p;
p = t;
}
delete p;
q = pValeurs;
while (q->p)
{
ElemListDouble* t = q->p;
delete q;
q = t;
}
delete q;
pFonction = new ElemListChar;
pValeurs = new ElemListDouble;
p = pFonction;
q = pValeurs;
transf(0,nDimCommande-1);
}
////////////////////////////////////////////////////////////////////////////////
//Rençoit la valeur en abscisse et renvoie l'ordonnée.
double fonction::valeur(double dX, bool& bOk)
{
//Initialisation des pointeur de travail p et q
p = pFonction;
q = pValeurs;
//Initialisation des variables utilisées par la fontion LectTransf()
dVarX = dX;
bValReel = true;
//Calcul récursif de la chaine à partir des pointeur p et q.
double dTemp = LectTransf();
if (bValReel) //Si la valeur est réelle
{
bOk = true;
return dTemp;
}
else //Si la valeur n'est pas réelle
{
bOk = false;
return 1;
}
}
////////////////////////////////////////////////////////////////////////////////
double fonction::LectTransf(void)
{
p = p->p;
switch (p->c)
{
// valeur
case 'v' : {
q = q->p;
return q->d;
} break;
// variable x
case 'x' : return dVarX; break;
// addition
case '+' : return LectTransf() + LectTransf(); break;
// soustraction
case '-' : return LectTransf() - LectTransf(); break;
// multiplication
case '*' : return LectTransf() * LectTransf(); break;
// division
case '/' : {
double dTemp1 = LectTransf();
double dTemp2 = LectTransf();
if (dTemp2 == 0)
{
bValReel = false;
return 1;
}
else
return dTemp1 / dTemp2;
} break;
// exposant
case '^' : {
double dTemp1 = LectTransf();
double dTemp2 = LectTransf();
if (dTemp1 > 0)
return pow(dTemp1,dTemp2);
else if (dTemp1 == 0)
if (dTemp2 == 0)
{
bValReel = false;
return 1;
}
else
return 0;
else if (floor(dTemp2) == dTemp2)
return pow(dTemp1,(int)dTemp2);
else
{
bValReel = false;
return 1;
}
} break;
// négation
case 'u' : return -LectTransf(); break;
// sinus
case 's' : return sin(LectTransf()); break;
// cosinus
case 'c' : return cos(LectTransf()); break;
// tangente
case 't' : {
double dTemp = LectTransf();
if (cos(dTemp) == 0)
{
bValReel = false;
return 1;
}
else
return tan(dTemp);
} break;
// logarithme népérien
case 'l' : {
double dTemp = LectTransf();
if (dTemp <= 0)
{
bValReel = false;
return 1;
}
else
return log(dTemp);
} break;
// logarithme en base 10
case 'L' : {
double dTemp = LectTransf();
if (dTemp <= 0)
{
bValReel = false;
return 1;
}
else
return log10(dTemp);
} break;
// arc sinus
case 'a' : {
double dTemp = LectTransf();
if ((dTemp < -1) || (dTemp > 1))
{
bValReel = false;
return 1;
}
else
return asin(dTemp);
} break;
// arc cosinus
case 'b' : {
double dTemp = LectTransf();
if ((dTemp < -1) || (dTemp > 1))
{
bValReel = false;
return 1;
}
else
return acos(dTemp);
} break;
// arc tangente
case 'd' : return atan(LectTransf()); break;
// sinus hyperbolique
case 'S' : return sinh(LectTransf()); break;
// cosinus hyperbolique
case 'C' : return cosh(LectTransf()); break;
// tangente hyperbolique
case 'T' : return tanh(LectTransf()); break;
// valeur absolue
case 'A' : {
double dTemp = LectTransf();
if (dTemp < 0)
return -dTemp;
else
return dTemp;
} break;
// partie entière
case 'E' : return floor(LectTransf()); break;
// partie décimale
case 'F' : {
double dTemp = LectTransf();
if (dTemp < 0)
return dTemp + floor(-dTemp);
else
return dTemp - floor(dTemp);
} break;
// valeur non réelle / non valide
case 'w' : {
bValReel = false;
return 1;
} break;
}
}
////////////////////////////////////////////////////////////////////////////////
void fonction::transf(int nDebut, int nFin)
{
int nComptePar,i;
bool bTemp;
if ((cVulg[nDebut] == '(') && (cVulg[nFin] == ')'))
{
nComptePar = 0;
bTemp = true;
for (i = nDebut; i < nFin; i++)
{
if (cVulg[i] == '(')
nComptePar++;
else if (cVulg[i] == ')')
nComptePar--;
bTemp = bTemp && (nComptePar != 0);
}
if (bTemp)
{
transf(nDebut+1,nDebut-1);
return;
}
}
bTemp = true;
for (i = nDebut; i <= nFin; i++)
bTemp = bTemp && (cVulg[i] != 'x');
if (bTemp)
{
bValReel = true;
double dTemp = LectVulg(nDebut,nFin);
if (bValReel)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'v';
q->p = new ElemListDouble;
q = q->p;
q->d = dTemp;
}
else
{
p->p = new ElemListChar;
p = p->p;
p->c = 'w';
}
return;
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '+') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
p->p = new ElemListChar;
p = p->p;
p->c = '+';
transf(nDebut,i-1);
transf(i+1,nFin);
return;
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '-') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
switch (cVulg[i-1])
{
case 'i' :; case 'e' :; case 'x' :; case ')' :; case '0' :;
case '1' :; case '2' :; case '3' :; case '4' :; case '5' :;
case '6' :; case '7' :; case '8' :; case '9' :
{
p->p = new ElemListChar;
p = p->p;
p->c = '-';
transf(nDebut,i-1);
transf(i+1,nFin);
return;
}
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '*') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
p->p = new ElemListChar;
p = p->p;
p->c = '*';
transf(nDebut,i-1);
transf(i+1,nFin);
return;
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '/') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
p->p = new ElemListChar;
p = p->p;
p->c = '/';
transf(nDebut,i-1);
transf(i+1,nFin);
return;
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '^') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
p->p = new ElemListChar;
p = p->p;
p->c = '^';
transf(nDebut,i-1);
transf(i+1,nFin);
return;
}
if (cVulg[0] == '-')
{
p->p = new ElemListChar;
p = p->p;
p->c = 'u';
transf(nDebut+1,nFin);
return;
}
if (strncmp(cVulg+nDebut,"sin(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 's';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"cos(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'c';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"tan(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 't';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"asin(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'a';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"acos(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'b';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"atan(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'd';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"sinh(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'S';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"cosh(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'C';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"tanh(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'T';
transf(nDebut+5,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"ln(",3) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'l';
transf(nDebut+3,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"log(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'L';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"abs(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'A';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"int(",4) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'E';
transf(nDebut+4,nFin-1);
return;
}
if (strncmp(cVulg+nDebut,"frac(",5) == 0)
{
p->p = new ElemListChar;
p = p->p;
p->c = 'F';
transf(nDebut+5,nFin-1);
return;
}
if (cVulg[0] = 'x')
{
p->p = new ElemListChar;
p = p->p;
p->c = 'x';
return;
}
}
////////////////////////////////////////////////////////////////////////////////
double fonction::LectVulg(int nDebut,int nFin)
{
int nComptePar,i;
if ((cVulg[nDebut] == '(') && (cVulg[nFin] == ')'))
{
nComptePar = 0;
bool bTemp = true;
for (i = nDebut; i < nFin; i++)
{
if (cVulg[i] == '(')
nComptePar++;
else if (cVulg[i] == ')')
nComptePar--;
bTemp = bTemp && (nComptePar != 0);
}
if (bTemp)
return LectVulg(nDebut+1,nFin-1);
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '+') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
return LectVulg(nDebut,i-1) + LectVulg(i+1,nFin);
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '-') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
switch (cVulg[i-1])
{
case 'i' :; case 'e' :; case ')' :; case '0' :; case '1' :;
case '2' :; case '3' :; case '4' :; case '5' :; case '6' :;
case '7' :; case '8' :; case '9' :
return LectVulg(nDebut,i-1) - LectVulg(i+1,nFin);
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '*') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
return LectVulg(nDebut,i-1) * LectVulg(i+1,nFin);
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '/') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
double dTemp = LectVulg(i+1,nFin);
if (dTemp == 0)
{
bValReel = false;
return 1;
}
else
return LectVulg(nDebut,i-1) / dTemp;
}
nComptePar = 0;
i = nFin;
do
{
if (cVulg[i] == ')')
nComptePar++;
else if (cVulg[i] == '(')
nComptePar--;
i--;
} while (((cVulg[i] != '^') || (nComptePar != 0)) && (i > nDebut));
if (i > nDebut)
{
double dTemp1 = LectVulg(nDebut,i-1);
double dTemp2 = LectVulg(i+1,nFin);
if (dTemp1 > 0)
return pow(dTemp1,dTemp2);
else if (dTemp1 == 0)
if (dTemp2 == 0)
{
bValReel = false;
return 1;
}
else
return 0;
else if (floor(dTemp2) == dTemp2)
return pow(dTemp1,(int)dTemp2);
}
if (cVulg[0] == '-')
return -LectVulg(nDebut+1,nFin);
if (strncmp(cVulg+nDebut,"sin(",4) == 0)
return sin(LectVulg(nDebut+4,nFin-1));
if (strncmp(cVulg+nDebut,"cos(",4) == 0)
return cos(LectVulg(nDebut+4,nFin-1));
if (strncmp(cVulg+nDebut,"tan(",4) == 0)
{
double dTemp = LectVulg(nDebut+4,nFin-1);
if (cos(dTemp) == 0)
{
bValReel = false;
return 1;
}
else
return tan(dTemp);
}
if (strncmp(cVulg+nDebut,"asin(",5) == 0)
{
double dTemp = LectVulg(nDebut+5,nFin-1);
if ((dTemp < -1) || (dTemp > 1))
{
bValReel = false;
return 1;
}
else
return asin(dTemp);
}
if (strncmp(cVulg+nDebut,"acos(",5) == 0)
{
double dTemp = LectVulg(nDebut+5,nFin-1);
if ((dTemp < -1) || (dTemp > 1))
{
bValReel = false;
return 1;
}
else
return acos(dTemp);
}
if (strncmp(cVulg+nDebut,"atan(",5) == 0)
return atan(LectVulg(nDebut+5,nFin-1));
if (strncmp(cVulg+nDebut,"sinh(",5) == 0)
return sinh(LectVulg(nDebut+5,nFin-1));
if (strncmp(cVulg+nDebut,"cosh(",5) == 0)
return cosh(LectVulg(nDebut+5,nFin-1));
if (strncmp(cVulg+nDebut,"tanh(",5) == 0)
return tanh(LectVulg(nDebut+5,nFin-1));
if (strncmp(cVulg+nDebut,"ln(",3) == 0)
{
double dTemp = LectVulg(nDebut+3,nFin-1);
if (dTemp <= 0)
{
bValReel = false;
return 1;
}
else
return log(dTemp);
}
if (strncmp(cVulg+nDebut,"log(",4) == 0)
{
double dTemp = LectVulg(nDebut+4,nFin-1);
if (dTemp <= 0)
{
bValReel = false;
return 1;
}
else
return log10(dTemp);
}
if (strncmp(cVulg+nDebut,"abs(",4) == 0)
{
double dTemp = LectVulg(nDebut+4,nFin-1);
if (dTemp < 0)
return -dTemp;
else
return dTemp;
}
if (strncmp(cVulg+nDebut,"int(",4) == 0)
return floor(LectVulg(nDebut+4,nFin-1));
if (strncmp(cVulg+nDebut,"frac(",5) == 0)
{
double dTemp = LectVulg(nDebut+5,nFin-1);
if (dTemp < 0)
return dTemp + floor(-dTemp);
else
return dTemp - floor(dTemp);
}
if (strncmp(cVulg+nDebut,"pi",2) == 0)
return 3.1415926535897932385;
if (cVulg[nDebut] == 'e')
return exp((double)1);
if ((cVulg[nDebut] >= '0') && (cVulg[nDebut] <= '9'))
{
i = nDebut;
double dTemp1 = 0;
while ((cVulg[i] != '.') && (i <= nFin))
{
dTemp1 = 10*dTemp1+cVulg[i]-48;
i++;
}
if (i < nFin)
{
double dTemp2 = 1;
while (++i <= nFin)
{
dTemp2 = dTemp2/10;
dTemp1 = dTemp1 + dTemp2*(cVulg[i]-48);
}
}
return dTemp1;
}
}
//Fin
Duchon.