Notation Polonaise inversée

Signaler
Messages postés
3
Date d'inscription
lundi 22 août 2005
Statut
Membre
Dernière intervention
13 décembre 2005
-
Messages postés
3
Date d'inscription
lundi 22 août 2005
Statut
Membre
Dernière intervention
13 décembre 2005
-
Slt, g un pti problème, g a réalisé un programme sur la notation polonaise inverséé et avec d chiffres ca marche nikel, mé je complike la vie pr trouver comment fer avec d nombres?
si quelqu'un pouvait m'aider
merci a l'avance
@++

5 réponses

Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Messages postés
3
Date d'inscription
lundi 22 août 2005
Statut
Membre
Dernière intervention
13 décembre 2005

Jlé déjà regardé mé ca marche pa avec les nombres, c ke pour les chiffres mais merci qd même
Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Le code est facile à modifier (dans la partie if((c>='0')&& (c<='9')), tant que c'est un chiffre tu multiplie par 10 et tu ajoutes le chiffre)
Messages postés
159
Date d'inscription
lundi 13 juin 2005
Statut
Membre
Dernière intervention
26 février 2009

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


#include


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 cCommande;





fonction f(cCommande,strlen(cCommande));





do


{


cout dX;


cout Nbr;


for (int i=0;ip)


{


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 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 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
Messages postés
3
Date d'inscription
lundi 22 août 2005
Statut
Membre
Dernière intervention
13 décembre 2005

ok merci le_duche, jvé allé regarD ca