Calculatrice notation scientifique

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Calculatrice notation scientifique

simius_computus

oh Gary boy

Salut

J'ai commencé le C en septembre, ça me faisait envie depuis longtemps mais j'avais la flemme de sortir de ce que je bidouillais en html/js ( [:inspecteur derrick] ). Evidemment c'est un autre univers, pour le moment je me limite à des trucs sur console, déjà il y a de quoi faire. Après avoir lu une bonne partie du Kernighan&Ritchie, plus le siteduzero, voici mon premier programme utile qui permet donc d'analyser et calculer la saisie de l'utilisateur en mode scientifique, avec les priorités d'opérateurs, les niveaux de parenthèses, la détection des erreurs de syntaxe et d'éventuelles divisions par zéro. Vlà le code :

Code :

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXLGHT 50 //taille autorisée pour la saisie
int getStr(char []); //enregistre la saisie jusqu'à \n en ignorant les espaces, renvoie le nombre de caractères (sauf \n)
double calc(char [], int); //traite la saisie, repère les erreurs de syntaxe, et gère l'exécution du calcul par niveaux avant de renvoyer le résultat final
int decp(int); //renvoie 10 puissance argument, utilisée pour lire les nombres dans la saisie
double lvlCalc(double*, double*, char*, int*); //renvoie le résultat de calcul sur un niveau de parenthèses en gérant la priorité des opérateurs et d'éventuelles divisions par zéro
int main()
{
int i, max = MAXLGHT;
char read[MAXLGHT]; //stocke la saisie brute
printf("Calculatrice en notation scientifique.\nLimite de caracteres : %d\n\n",max);
for(;;)
{
i = getStr(read);
if(i <= MAXLGHT)
printf("%f\n\n",calc(read, i)); //appelle calc si la saisie ne dépasse pas la taille autorisée
else
printf("depassement : %d caracteres max\n", MAXLGHT);
}
return 0;
}
int getStr(char c[])
{
char temp;
int i = 0;
for(;;)
if((temp = getchar()) != '\n')
c[(isspace(temp))?i:i++] = temp;
else
break;
c[i] = '\0';
return i;
}
int decp(int a)
{
int i, p = 1;
for (i = 0; i < a; i++)
p = p * 10;
return p;
}
double calc(char str[], int cSize)
{
double result = 0.0; //stocke résultat final
double curNb = 0.0; //variable temp pour lecture des nombres
double calcFormat[cSize]; //stocke la saisie sous sa forme calculable, opérateurs et opérandes uniquement
int lvls[cSize]; //stocke les niveaux de parenthèses de chaque opérateur ou opérande
char type[cSize]; //détermine la nature de chaque élément de calcFormat : 'o' pour opérateur, 'd' pour nombre, 'v' pour à ignorer (déjà pris en compte dans un niveau supérieur)
int zdiv = 0; //division par zéro
int decInd = 0; //variable temp pour calcul des nombres à partie décimale
int curLvl = 1; //niveau de parenthèses en cours de traitement
int topLvl = 1; //plus grand niveau de parenthèses (on commence par là)
int error = 0; //erreur(s)
int i, j, k = 0; //indices
for(i = 0; i < cSize && error == 0; i++) //construit calcFormat[], lvls[], type[], repère les erreurs de syntaxe
{
if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
{
if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
++error;
for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
{
curNb = 10 * curNb + (str[i] - '0');
if(str[i+1] == '.') //on rencontre un point de décimal
{
if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
{
i++;
decInd = j + 1; //mémorise sa place dans le nombre courant
}
else
++error;
}
}
calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
type[k] = 'd'; //l'élément est un nombre
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
decInd = 0;
curNb = 0.0;
i--;
}
else if(str[i] == '(') //saute les parenthèses ouvrantes et incrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
{
if(i == 0 || (i > 0 && i < cSize - 1 && str[i-1] != ')' && !isdigit(str[i-1])))
{
++curLvl;
if(curLvl > topLvl) //si le niveau est plus grand que le plus grand rencontré, mettre à jour ce dernier
topLvl = curLvl;
}
else
++error;
}
else if(str[i] == ')') //saute les parenthèses fermantes et décrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
{
if(i > 0 && str[i-1] != '(' && str[i-1] != '+' && str[i-1] != '-' && str[i-1] != '*' && str[i-1] != '/')
--curLvl;
else
++error;
}
else if(str[i] == '+' || str[i] == '*' || str[i] == '/') //les opérateurs +, * et / ont les mêmes règles de syntaxe
{
if(i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')'))
{
calcFormat[k] = str[i];
type[k] = 'o'; //l'élément est un opérateur
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
}
else
++error;
}
else if(str[i] == '-') //règle de syntaxe pour l'opérateur -
{
if((i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')' || str[i-1] == '(')) || (i == 0 && cSize > 1))
{
calcFormat[k] = str[i];
type[k] = 'o'; //l'élément est un opérateur
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
}
else
++error;
}
else //ni un nombre, ni une parenthèse, ni un opérateur
++error;
}
calcFormat[k] = '\0';
lvls[k] = '\0';
type[k] = '\0';
if(curLvl != 1) //si il n'y a pas autant de '(' que de ')'
++error;
if(error == 0) //si pas d'erreur
{
int left, right; //champ d'action de lclCalc dans calcFormat[]
for(; topLvl >= 1; topLvl--) //examine chaque niveau du plus élevé à 1
{
for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
{
for(; lvls[i] < topLvl; ++i) //saute les niveaux inférieurs
;
left = i;
for(; lvls[i] >= topLvl; ++i)
;
right = i-1;
result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
calcFormat[left] = result; //stocke le résultat à gauche
--lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
if(zdiv) //lvlCalc a indiqué une division par zéro
{
printf("division par zero !\n" );
return 0.0;
}
}
}
}
else
printf("erreur de syntaxe\n" );
return result;
}
double lvlCalc(double* start, double* end, char* opCheck, int* zdiv)
{
double result = 0.0; //résultat pour la plage donnée à calculer
double* stemp = start; //compteur pour la 1ère boucle, pointe sur les éléments de calcFormat[]
double* first = start; //garde en mémoire l'élément de gauche
char* opStart = opCheck; //compteur pour la 1ère boucle, pointe sur les éléments de type[]
int leftSp = 0, rightSp = 0; //variables pour le saut les éléments de type 'v' situés autour des opérateurs * et /
for(; stemp <= end; stemp++, opStart++) //première boucle sur l'étendue indiquée
{
if(*stemp == '*' && *opStart == 'o') //rencontre un opérateur *
{
for(; *(opStart-1-leftSp) == 'v'; leftSp++) //saute les éléments de type 'v' à gauche
;
for(; *(opStart+1+rightSp) == 'v'; rightSp++) //saute les éléments de type 'v' à droite
;
*(stemp-1-leftSp) = *(stemp-1-leftSp) * *(stemp+1+rightSp); //stocke le résultat dans l'opérande de gauche
*opStart = 'v'; //indique l'opérateur comme déjà utilisé
*(opStart+1+rightSp) = 'v'; //indique l'opérande de droite comme déjà utilisé
opStart += 1+rightSp; //saute la plage qu'on vient de calculer
stemp += 1+rightSp; //pareil avec l'autre indice
}
else if(*stemp == '/' && *opStart == 'o') //rencontre un opérateur / (même méthode que pour *)
{
for(; *(opStart-1-leftSp) == 'v'; leftSp++)
;
for(; *(opStart+1+rightSp) == 'v'; rightSp++)
;
if(*(stemp+1+rightSp) != 0) //opérande de droite != 0
*(stemp-1-leftSp) = *(stemp-1-leftSp) / *(stemp+1+rightSp);
else //division par zéro
{
*zdiv = 1;
return 0.0;
}
*opStart = 'v';
*(opStart+1+rightSp) = 'v';
opStart += 1+rightSp;
stemp += 1+rightSp;
}
} //les opérations prioritaires ont été effectuées, reste que des additions et soustractions dans l'étendue indiquée
if(*opCheck == 'd') //additionne au résultat l'élément tout à gauche si c'est un nombre (ça pourrait être un opérateur -)
result += *start;
for(; start <= end; start++, opCheck++) //seconde boucle sur l'étendue indiquée
{
if(*start == '+' && *opCheck == 'o') //rencontre un opérateur +
{
for(; *(opCheck+1) == 'v'; opCheck++, start++) //saute les éléments déjà utilisés à droite jusqu'à rencontrer un opérande
;
result += *(start+1); //additionne l'opérande au résultat
*opCheck = 'v'; //l'opérateur est marqué comme déjà utilisé
*(opCheck+1) = 'v'; //l'opérande est marqué comme déjà utilisé
}
if(*start == '-' && *opCheck == 'o') //même principe pour -
{
for(; *(opCheck+1) == 'v'; opCheck++, start++)
;
result -= *(start+1);
*opCheck = (start > first)?'v':'d'; //comme l'opérateur - peut se trouver en premier élément, on veille à le marquer comme nombre pour que le résultat stocké dedans ne soit pas ignoré par les niveaux suivants
*(opCheck+1) = 'v';
}
}
return result;
}

Alors déjà, si vous voulez le tester dans tous les sens, j'ai peut-être négligé des choses.
Et puis au niveau du code il y a sûrement moyen d'optimiser, tant en volume de code source (utiliser des macros ?) qu'en performances dans l'exécution, je suis preneur de vos conseils. J'ai essayé de mettre des commentaires qui rendent la chose plus facile à examiner

Merci,

Message édité par simius_computus le 17-11-2012 à 22:40:48

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Publicité

Sve@r

Salut

Pour un programme de débutant c'est plus qu'excellent. Bon ta façon de faire n'est pas super claire mais c'est inhérent à tout le monde (on a toujours l'impression que nos commentaires sont super explicites et que ceux des autres ne le sont pas assez) et je suis sûr qu'en s'y attelant une dizaine de minutes on perçoit facilement ta méthode.

Sinon j'ai tapé qq essais

Citation :

C:\temp>a.exe
Calculatrice en notation scientifique.
Limite de caracteres : 50

(2+3)*5
25.000000

(2+(3*5)+2)
19.000000

((2+6)*(1+1))
16.000000

^C
C:\temp>
C:\temp>

Et comme tu vois, pour moi zéro souci...

Pour l'optimisation bien entendu faut d'abord avoir compris ton algo. Mais ne compte pas sur les macros pour ça car celles-ci sont intégralement retraduites avant compilation.

Maintenant (après une seconde lecture) petite erreur que j'ai remarqué dans decp(). Tu mets p à 1 si a > 0 sinon tu mets p à 0 puis tu multiplies ce p "a" fois. Là il y a une maladresse car il faut relire ce code 2 ou 3 fois pour comprendre que dans le cas où a vaut 0, la boucle ne sera pas traitée et la valeur renvoyée sera finalement 0.

Une façon d'écrire que je trouve plus claire aurait pu être celle-ci

Code :

int decp(int a)
{
    int i, p;
 
    if (a == 0) return 0;
    for (i=0, p=1; i < a; i++)
        p = p * 10;
    return p;
}

Ainsi je commence toujours par éliminer les cas particuliers ou erronés avant de m'attaquer au cas général. Je sais que le puriste va hurler devant cette fonction ayant plus d'un return mais ma philosophie est de dire qu'un bon programmeur respecte les règles tandis qu'un programmeur brillant les transgresse parfois.

Sinon, accessoirement, 10^0=1 ...

Message édité par Sve@r le 17-11-2012 à 21:56:10

simius_computus

oh Gary boy

Merci d'avoir pris le temps de regarder ! pour les tests, j'ai dû imaginer pas mal de cas, ce qui m'a amener à compléter le code au fur et à mesure.. La partie chiante quoi, avec des printf partout pour contrôler ce qui se passe.

Effectivement decp() était pas terrible. Je sais pas trop ce que j'ai foutu, pas besoin de cette condition sur p, tout simplement :

Code :

int decp(int a)
{
int i, p = 1;
for (i = 0; i < a; i++)
p = p * 10;
return p;
}

Fonctionne très bien.
J'ai édité mon post, en rajoutant des commentaires qui me semblaient utiles justement autour de l'unique appel à cette fonction, au début de calc() :

Code :

if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
{
if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
++error;
for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
{
curNb = 10 * curNb + (str[i] - '0');
if(str[i+1] == '.') //on rencontre un point de décimal
{
if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
{
i++;
decInd = j + 1; //mémorise sa place dans le nombre courant
}
else
++error;
}
}
calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
type[k] = 'd'; //l'élément est un nombre
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
decInd = 0;
curNb = 0.0;
i--;
}

Donc, de toute façon decp() ne peut pas recevoir zéro vu qu'on l'appelle avec pour argument (j - decInd) avec la condition decInd != j
Mais c'est plus cohérent d'avoir une fonction qui renvoie 1 pour 10^0, oui !

Sinon, pourquoi c'est mal d'avoir plusieurs return ?

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

simius_computus

oh Gary boy

Ah merde, bug détecté. Va falloir ressortir les printf
Je pense que ma méthode est un peu tordue, il doit y avoir des chemins plus simples.

Message cité 1 fois

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Farian

Bonsoir !

Vous devriez passer le paramètre MAXLGHT à la fonction "GetStr", car en l'état, si la personne saisit plus de caractères que prévu, vous obtenez un dépassement mémoire, alors que vous pourriez facilement faire le test dans la fonction GetStr pour régler le problème à la source.

Bon courage pour votre bug !

simius_computus

oh Gary boy

Salut,
Effectivement, je vais modifier GetStr, merci pour la remarque !
Et j'ai déniché le bug : une simple histoire de variables temporaires pas remises à zéro, demain je posterai le code corrigé

Au fait, y a-t-il un moyen de coller du texte dans ma console, à partir d'une expression copiée dans windows ?

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

simius_computus

oh Gary boy

Version corrigée :

Code :

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXLGHT 50 //taille autorisée pour la saisie
int getStr(char []); //enregistre la saisie jusqu'à \n en ignorant les espaces, renvoie le nombre de caractères (sauf \n)
double calc(char [], int); //traite la saisie, repère les erreurs de syntaxe, et gère l'exécution du calcul par niveaux avant de renvoyer le résultat final
int decp(int); //renvoie 10 puissance argument, utilisée pour lire les nombres dans la saisie
double lvlCalc(double*, double*, char*, int*); //renvoie le résultat de calcul sur un niveau de parenthèses en gérant la priorité des opérateurs et d'éventuelles divisions par zéro
int main()
{
int i;
char read[MAXLGHT]; //stocke la saisie brute
printf("Calculatrice en notation scientifique.\nLimite de caracteres : %d\n\n", MAXLGHT);
for(;;)
{
i = getStr(read);
if(i <= MAXLGHT)
printf("%f\n\n",calc(read, i)); //appelle calc si la saisie ne dépasse pas la taille autorisée
else
printf("depassement : %d caracteres max\n\n", MAXLGHT);
}
return 0;
}
int getStr(char c[])
{
char temp;
int i = 0;
for(;;)
if((temp = getchar()) != '\n')
if(i < MAXLGHT)
c[(isspace(temp)) ? i : i++] = temp;
else
i++;
else
break;
c[i] = '\0';
return i;
}
int decp(int a)
{
int i, p = 1;
for (i = 0; i < a; i++)
p = p * 10;
return p;
}
double calc(char str[], int cSize)
{
double result = 0.0; //stocke résultat final
double curNb = 0.0; //variable temp pour lecture des nombres
double calcFormat[cSize]; //stocke la saisie sous sa forme calculable, opérateurs et opérandes uniquement
int lvls[cSize]; //stocke les niveaux de parenthèses de chaque opérateur ou opérande
char type[cSize]; //détermine la nature de chaque élément de calcFormat : 'o' pour opérateur, 'd' pour nombre, 'v' pour à ignorer (déjà pris en compte dans un niveau supérieur)
int zdiv = 0; //division par zéro
int decInd = 0; //variable temp pour calcul des nombres à partie décimale
int curLvl = 1; //niveau de parenthèses en cours de traitement
int topLvl = 1; //plus grand niveau de parenthèses (on commence par là)
int error = 0; //erreur(s)
int i, j, k = 0; //indices
for(i = 0; i < cSize && error == 0; i++) //construit calcFormat[], lvls[], type[], repère les erreurs de syntaxe
{
if(isdigit(str[i])) //calcule les nombres avec leur partie décimale éventuelle
{
if(i > 0 && str[i-1] == ')') //erreur si un nombre suit directement une parenthèse
++error;
for(j = 0; isdigit(str[i]) && error == 0; i++, j++)
{
curNb = 10 * curNb + (str[i] - '0');
if(str[i+1] == '.') //on rencontre un point de décimal
{
if(decInd == 0) //vérifie que c'est le premier rencontré pour le nombre courant
{
i++;
decInd = j + 1; //mémorise sa place dans le nombre courant
}
else
++error;
}
}
calcFormat[k] = (decInd > 0 && decInd != j) ? curNb / (decp(j - decInd)) : curNb; //si on a une partie décimale et qu'elle n'est pas vide (au moins un chiffre après le point), diviser le nombre par 10 puissance le nombre de décimales
type[k] = 'd'; //l'élément est un nombre
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
decInd = 0;
curNb = 0.0;
i--;
}
else if(str[i] == '(') //saute les parenthèses ouvrantes et incrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
{
if(i == 0 || (i > 0 && i < cSize - 1 && str[i-1] != ')' && !isdigit(str[i-1])))
{
++curLvl;
if(curLvl > topLvl) //si le niveau est plus grand que le plus grand rencontré, mettre à jour ce dernier
topLvl = curLvl;
}
else
++error;
}
else if(str[i] == ')') //saute les parenthèses fermantes et décrémente le niveau en conséquence, repère d'éventuelles erreurs de syntaxe
{
if(i > 0 && str[i-1] != '(' && str[i-1] != '+' && str[i-1] != '-' && str[i-1] != '*' && str[i-1] != '/')
--curLvl;
else
++error;
}
else if(str[i] == '+' || str[i] == '*' || str[i] == '/') //les opérateurs +, * et / ont les mêmes règles de syntaxe
{
if(i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')'))
{
calcFormat[k] = str[i];
type[k] = 'o'; //l'élément est un opérateur
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
}
else
++error;
}
else if(str[i] == '-') //règle de syntaxe pour l'opérateur -
{
if((i > 0 && i < cSize - 1 && (isdigit(str[i-1]) || str[i-1] == ')' || str[i-1] == '(')) || (i == 0 && cSize > 1))
{
calcFormat[k] = str[i];
type[k] = 'o'; //l'élément est un opérateur
lvls[k++] = curLvl; //le niveau de l'élément est le niveau courant
}
else
++error;
}
else //ni un nombre, ni une parenthèse, ni un opérateur
++error;
}
calcFormat[k] = '\0';
lvls[k] = '\0';
type[k] = '\0';
if(curLvl != 1) //si il n'y a pas autant de '(' que de ')'
++error;
if(error == 0) //si pas d'erreur
{
int left, right; //champ d'action de lclCalc dans calcFormat[]
for(; topLvl >= 1; topLvl--) //examine chaque niveau du plus élevé à 1
{
//printf("\nlevel %d\n",topLvl);
for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
{
for(; lvls[i] < topLvl; i++) //saute les niveaux inférieurs
;
left = i;
for(; lvls[i] >= topLvl; i++) //détermine la plage à prendre en compte, qui sera encadrée par left et right
;
right = i-1;
//printf("left = %d right = %d\n",left,right);
result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
calcFormat[left] = result; //stocke le résultat à gauche
--lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
if(zdiv) //lvlCalc a indiqué une division par zéro
{
printf("division par zero !\n" );
return 0.0;
}
}
//for(i=0;i<k;i++)
//printf("val = %f lvl = %d type = %c\n",calcFormat[i],lvls[i],type[i]);
}
}
else
printf("erreur de syntaxe\n" );
return result;
}
double lvlCalc(double* start, double* end, char* opCheck, int* zdiv)
{
double result = 0.0; //résultat pour la plage donnée à calculer
double* stemp = start; //compteur pour la 1ère boucle, pointe sur les éléments de calcFormat[]
double* first = start; //garde en mémoire l'élément de gauche
char* opStart = opCheck; //compteur pour la 1ère boucle, pointe sur les éléments de type[]
int leftSp, rightSp; //variables pour le saut les éléments de type 'v' situés autour des opérateurs * et /
for(; stemp <= end; stemp++, opStart++) //première boucle sur l'étendue indiquée
{
if(*stemp == '*' && *opStart == 'o') //rencontre un opérateur *
{
for(leftSp = 0; *(opStart-1-leftSp) == 'v'; leftSp++) //saute les éléments de type 'v' à gauche
;
for(rightSp = 0; *(opStart+1+rightSp) == 'v'; rightSp++) //saute les éléments de type 'v' à droite
;
*(stemp-1-leftSp) = *(stemp-1-leftSp) * *(stemp+1+rightSp); //stocke le résultat dans l'opérande de gauche
*opStart = 'v'; //indique l'opérateur comme déjà utilisé
*(opStart+1+rightSp) = 'v'; //indique l'opérande de droite comme déjà utilisé
opStart += 1+rightSp; //saute la plage qu'on vient de calculer
stemp += 1+rightSp; //pareil avec l'autre indice
}
else if(*stemp == '/' && *opStart == 'o') //rencontre un opérateur / (même méthode que pour *)
{
for(leftSp = 0; *(opStart-1-leftSp) == 'v'; leftSp++)
;
for(rightSp = 0; *(opStart+1+rightSp) == 'v'; rightSp++)
;
if(*(stemp+1+rightSp) != 0) //opérande de droite != 0
*(stemp-1-leftSp) = *(stemp-1-leftSp) / *(stemp+1+rightSp);
else //division par zéro
{
*zdiv = 1;
return 0.0;
}
*opStart = 'v';
*(opStart+1+rightSp) = 'v';
opStart += 1+rightSp;
stemp += 1+rightSp;
}
} //les opérations prioritaires ont été effectuées, reste que des additions et soustractions dans l'étendue indiquée
if(*opCheck == 'd') //additionne au résultat l'élément tout à gauche si c'est un nombre (ça pourrait être un opérateur -)
result += *start;
for(; start <= end; start++, opCheck++) //seconde boucle sur l'étendue indiquée
{
if(*start == '+' && *opCheck == 'o') //rencontre un opérateur +
{
for(; *(opCheck+1) == 'v'; opCheck++, start++) //saute les éléments déjà utilisés à droite jusqu'à rencontrer un opérande
;
result += *(start+1); //additionne l'opérande au résultat
*opCheck = 'v'; //l'opérateur est marqué comme déjà utilisé
*(opCheck+1) = 'v'; //l'opérande est marqué comme déjà utilisé
}
if(*start == '-' && *opCheck == 'o') //même principe pour -
{
for(; *(opCheck+1) == 'v'; opCheck++, start++)
;
result -= *(start+1);
*opCheck = (start > first)?'v':'d'; //comme l'opérateur - peut se trouver en premier élément, on veille à le marquer comme nombre pour que le résultat stocké dedans ne soit pas ignoré par les niveaux suivants
*(opCheck+1) = 'v';
}
}
return result;
}

Après moult tests sur des calculs bien fournis, je pense que cette version est correcte.
Il faudrait ajouter quelques opérateurs comme racine carrée et fonctions trigo mais pfff.. On verra plus tard [:clooney9]

Message édité par simius_computus le 18-11-2012 à 10:21:47

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Farian

Tout d'abord bravo pour votre apprentissage réussi !

J'émets toutefois quelques doutes sur la capacité à rajouter beaucoup de fonctionnalités, notamment à cause de l'analyse syntaxique faite "à la main". Si vous voulez réellement poursuivre dans cette voie, je ne saurais que vous conseiller de vous tourner vers des outils particulièrement adaptés : lex/yacc (ou flex/bison, en version GNU, j'ai l'habitude d'utiliser la vieille dénomination UNIX), qui permettent de faire de l'analyse syntaxique/grammaticale. La programmation d'une calculatrice est d'ailleurs l'un des premiers exercices pour ces outils.

Mais cela déborde peut-être (sûrement ?) de votre but, qui est de vous mettre au C.

Bon courage en tous cas !

Profil supprimé

Je préfère les balise C pour le code C.
/Forte tête.

Message cité 1 fois

simius_computus

oh Gary boy

Farian a écrit :

Tout d'abord bravo pour votre apprentissage réussi !

J'émets toutefois quelques doutes sur la capacité à rajouter beaucoup de fonctionnalités, notamment à cause de l'analyse syntaxique faite "à la main". Si vous voulez réellement poursuivre dans cette voie, je ne saurais que vous conseiller de vous tourner vers des outils particulièrement adaptés : lex/yacc (ou flex/bison, en version GNU, j'ai l'habitude d'utiliser la vieille dénomination UNIX), qui permettent de faire de l'analyse syntaxique/grammaticale. La programmation d'une calculatrice est d'ailleurs l'un des premiers exercices pour ces outils.

Mais cela déborde peut-être (sûrement ?) de votre but, qui est de vous mettre au C.

Bon courage en tous cas !

Merci

J'ai regardé un peu la doc sur cet outil, c'est clair que ça doit simplifier vachement.
Mon truc ça reste un exercice, pour appliquer les bases, manipuler les chaînes, les tableaux, un peu de manips sur les pointeurs..
Pour le moment je découvre les possibilités du langage, il faudrait que j'installe une partition linux déjà
Rien qu'avec la librairie standard il y a de quoi faire, après j'aurai probablement envie de développer des applis graphiques, on verra

Je pense faire un bts IRIS l'an prochain en alternance, ça devrait être plus facile de trouver une bonne boîte en ayant déjà des acquis.

Message édité par simius_computus le 18-11-2012 à 10:59:00

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Publicité

simius_computus

oh Gary boy

Où en est ton IA ?

Message cité 1 fois

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Profil supprimé

simius_computus a écrit :

Où en est ton IA ?

J'écris un compositeur pour instrument MIDI actuellement.
Celui ci exploite les réseaux de neurones.
Si non, il y a jovalise.net, toujours au même point.

simius_computus

oh Gary boy

le jovalise.net n'a pas changé effectivement

Citation :

Votre requête

Bonjour monsieur.

Ma réponse

rassasiées retournerais

[:marllt2]

Je suis curieux de savoir comment tu procèdes, avoue, c'est juste du random sur une banque de mots ?
Appliqué à la composition de musique ça peut donner des trucs intéressants remarque

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Profil supprimé

Du tout. ça passe réellement par un réseau de neurone.
L'aléatoire en musique... C'est pas la panacée.

simius_computus

oh Gary boy

Mais comment ton machin apprend-il ?
On ne peut pas lui signaler ses incohérences.

Message cité 1 fois

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Profil supprimé

simius_computus a écrit :

Mais comment ton machin apprend-il ?
On ne peut pas lui signaler ses incohérences.

Il a d'abord appris un ficher d'exemple. puis au bout d'un certain nombre de requête il repart en apprentissage avec les requête et les réponse qu'il a donné.

simius_computus

oh Gary boy

Je ne connais rien en réseaux de neurones, mais ça m'intéresse. Tout ce qui est IA, apprentissage [:zero pm:5]

(pour la théorie musicale, par contre je connais )

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Sve@r

simius_computus a écrit :

pour les tests, j'ai dû imaginer pas mal de cas, ce qui m'a amener à compléter le code au fur et à mesure..

Aïe, ça c'est embêtant. Parce qu'en procédant ainsi, tu risques de rater certains cas...

simius_computus a écrit :

Ah merde, bug détecté. Va falloir ressortir les printf

Et voilà

simius_computus a écrit :

Je pense que ma méthode est un peu tordue, il doit y avoir des chemins plus simples.

Peut-être. Par exemple qu'est-ce qu'une expression ? C'est
1: nombre opérande nombre => 2 + 2
Ou bien
2: nombre opérande "définition 1" => 2 + 3 + 4 => 2 + 3 + 4 + 5 ...
Ou bien
3: ( "définition 2" ) => (2 + 3 + 4 + 5)

En utilisant la définition 3, qui elle-même se base sur la définition 2 qui est basée sur la définition 1, tu couvres tous les cas possibles. Imagine donc une fonction ayant pour but de calculer le résultat d'une expression définie en 2 (que des nombres et des opérandes) et qui, dès qu'elle détecte une parenthèse, se met en attente du résultat de ce qu'il y a entre parenthèses avant de continuer. Et ce résultat pourrait être donné par un clone de cette même fonction mais exécuté dans un sous-contexte.
Ben toute cette manipulation est rendue possible par l'utilisation astucieuse de la récursivité. Avec en amont de tout ça une première fonction dédiée à vérifier la syntaxe générale (surtout au niveau de la parité des parenthèses) et là tu es certain que ton code couvre toutes les combinaisons...

Et, accessoirement, il a été cité dans ce topic lex et yacc, outils justement dédiés à ce genre de problème. Tu décris dans un fichier texte comment tu définis une expression (comme je l'ai fait au dessus) et yacc génère automatiquement le code C correspondant pour traiter une expression. Et lex te permet de programmer le vérificateur de syntaxe. Malheureusement ces outil sont issus du monde Unix et je ne sais pas s'ils existent pour zindow. Mais bon, rien n'interdit de programmer tout ça manuellement surtout si c'est pour se faire un bon exercice...

Message édité par Sve@r le 18-11-2012 à 14:32:38

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

simius_computus

oh Gary boy

La récursion en partant du bas (1er niveau dans les parenthèses), ouais.. Moi j'ai procédé à l'inverse :

1- chercher la ou les expression(s) appartenant au dernier niveau;
2- calculer le(s) résultat(s) et le(s) placer à gauche dans l'expression correspondante, les autres éléments de l'expression étant marqués comme à ignorer pour la suite;
3- décrémenter la valeur "dernier niveau" et retourner à l'étape 1, ou terminer si on a parcouru tous les niveaux

A mon avis ce système est gourmand avec des boucles qui parcourent l'ensemble de la chaîne, à voir si la récursion offre un avantage, en tout cas j'ai pas dû prendre les options les plus efficaces c'est clair.
C'est dans les détails du calcul de chaque expression que j'ai eu des problèmes de cas particuliers à détecter, pour le dernier bug c'est une étourderie qui avait la mauvaise idée de se compenser d'elle-même dans la majorité des cas [:fabriceboue]

Je compte pas m'éterniser sous windows

Je vais essayer d'autres trucs, et reviendrai sur ce code probablement plus tard pour trouver plus élégant. Merci pour les infos

Message édité par simius_computus le 18-11-2012 à 15:01:20

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

rufo

Pas me confondre avec Lycos!

Lex/yacc, bonne idée. Si c'est dans un but d'apprentissage, cet article sur la grammaire LL devrait t'aider : http://fr.wikipedia.org/wiki/Analyse_LL

Un codage à base d'arbre serait pas mal : tu décomposes ton expression en feuilles (nombres) et les noeuds sont les opérateurs.

J'ai un souci avec ton for( ; ; ) qui pourrait être remplacé de manière plus lisible (à mon avis) par un while. D'un point de vue purement algorithmique, c'est plus logique, donc probablement plus lisible

mais c'est du très bon niveau pour qq'un qui pratique le C depuis qq mois seulement :jap:

Message cité 1 fois
Message édité par rufo le 22-11-2012 à 11:15:20

---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta

gilou

Modérateur
Modzilla

Simius,
Pour quelqu'un qui a démarré le C en Septembre, ce que tu as fait est très bien.
Ne t'inquiètes pas du commentaires 'c'est mieux avec lex/yacc (ou flex/bison plutôt)' ou de celui critiquant ton 'ce qui m'a amener à compléter le code au fur et à mesure', quand on a démarré la programmation, on a tous procédé ainsi, les manières pour mieux faire, on les apprends avec l'expérience (qui permet de comprendre pourquoi une méthode est meilleure qu'une autre).

Une petite remarque: quand tu veux auto-incrémenter une valeur, pré-incrémentes la: ++i
N'utilises la post-incrémentation (i++) que quand ça a un sens dans le programme de d'abord évaluer la valeur puis de l'incrémenter (j = i++ etc).
C'est une bonne habitude à prendre dès le début (et autrefois, de plus, sur certaines architectures, la pré-incrémentation était plus rapide).

Bon, je vais lire le code un peu plus en détail...

A+,

Message édité par gilou le 22-11-2012 à 11:45:15

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

gilou

Modérateur
Modzilla

Bon, alors ce qui ne me plait pas dans ce code:

- Il n'est pas prévu de sortir du programme autrement que avec Ctrl+C apparemment. Le faire sur une ligne entrée vide me semblerait logique.
- int getStr(char c[]) Tu passes une variable cachée à cette fonction, MAXLGHT.
définis la plutôt comme int getStr(char c[], int maxlen) et appelles la avec i = getStr(read, MAXLGHT);
Note: une autre définition possible pourrait être int getStr(char (*c)[MAXLGHT]); avec un appel i = getStr(&read); mais c'est un niveau un poil plus avancé, ou on dit explicitement que le paramètre est l'adresse d'un tableau de MAXLGHT chars.

Bon, je vais manger.

Bon, il y a sans doute des choses à améliorer dans l'algo, car en traçant un peu:
/* * */ printf("left = %f right = %f type = %c ", calcFormat[left], calcFormat[right], type[left]);
result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
/* * */ printf("result = %f\n", result);
je vois ceci, avec un appel inutile manifestement:
1+(2.1*3)-2
left = 2.100000 right = 3.000000 type = d result = 6.300000
left = 0.000000 right = 0.000000 type = ¶ result = 0.000000
left = 1.000000 right = 2.000000 type = d result = 5.300000
5.300000

il pourrait peut être aussi être moins strict sur ce qui passe en entrée:
+2
erreur de syntaxe
0.000000

3 * -1
erreur de syntaxe
0.000000

A+,

Message cité 1 fois
Message édité par gilou le 22-11-2012 à 14:40:38

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

simius_computus

oh Gary boy

Merci pour votre expertise :jap:

rufo a écrit :

Quel for( ; ; ) ? J'en ai mis deux, conscient que c'était une solution pas forcément élégante :whistle:
Dans main() je pourrais le remplacer par un truc qui met fin au programme comme l'a suggéré Gilou.
Pour la grammaire, je regarde ça, intéressant mais c'est quand même assez abstrait [:altherac:1]
(wikipédia ne m'a jamais semblé didactique)

Je note pour la place de l'incrément, c'est en effet logique.

En quoi l'utilisation de MAXLGHT est-elle gênante dans getStr ? ("variable cachée" ?)

Alors pour l'erreur dans ton traçage, je crois avoir remarqué ce truc avant mais j'ai oublié de chercher une correction vu que ça n'empêchait pas le fonctionnement.
Un problème de référence à des éléments de tableau pas encore définis je pense. Vais essayer d'arranger ça !

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

simius_computus

oh Gary boy

gilou a écrit :

je vois ceci, avec un appel inutile manifestement:
1+(2.1*3)-2
left = 2.100000 right = 3.000000 type = d result = 6.300000
left = 0.000000 right = 0.000000 type = ¶ result = 0.000000
left = 1.000000 right = 2.000000 type = d result = 5.300000
5.300000

Bon, c'est corrigé, quelques conditions en plus dans la boucle qui appelle lvlCalc() :

Code :

for(i = 0; i < k; i++) //repère les parties correspondant au niveau topLvl
{
for(; lvls[i] < topLvl && i < k; i++) //saute les niveaux inférieurs
;
if(i == k)
break;
left = i;
for(; lvls[i] >= topLvl; i++) //détermine la plage à prendre en compte, qui sera encadrée par left et right
;
right = i-1;
result = lvlCalc(&calcFormat[left], &calcFormat[right], &type[left], &zdiv); //calcule le niveau en cours
calcFormat[left] = result; //stocke le résultat à gauche
--lvls[left]; //décrémente le niveau de l'élément contenant le résultat afin qu'il soit pris en compte par le niveau suivant
if(zdiv) //lvlCalc a indiqué une division par zéro
{
printf("division par zero !\n" );
return 0.0;
}
}

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Farian

Citation :

En quoi l'utilisation de MAXLGHT est-elle gênante dans getStr ? ("variable cachée" ?)

La variable est cachée dans le sens où vous déclarez votre tableau avec cette taille-là, mais vous ne l'utilisez pas dans la fonction getStr, puis vous comparez le résultat à cette valeur en sortie de la fonction.

Si l'utilisateur rentre une "phrase" trop longue, vous aurez tout d'abord un écrasement mémoire dans la fonction getStr à cause du dépassement du nombre de valeurs allouées, puis, si le dépassement n'a pas tout déstabilisé, vous affichez une erreur en disant que le nombre maximum de caractères autorisés est dépassé, mais le mal est (peut-être) déjà fait.

Message édité par Farian le 22-11-2012 à 22:06:00

simius_computus

oh Gary boy

Pourtant j'utilise MAXLGHT dans getStr()

Code :

int getStr(char c[])
{
char temp;
int i = 0;
for(;;)
if((temp = getchar()) != '\n')
if(i < MAXLGHT)
c[(isspace(temp)) ? i : i++] = temp;
else
i++;
else
break;
c[i] = '\0';
return i;
}

En toute logique, si l'utilisateur dépasse MAXLGHT caractères en entrée, le tableau passé en argument ne sera plus rempli, seul i sera incrémenté non ?
Je pense qu'il y a un truc que je ne saisis pas..

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Farian

En effet, j'avais mal vu ! La façon de faire n'est pas la plus élégante (pour que la fonction soit plus facilement réutilisable, il faudrait passer la taille à laquelle la chaîne a été allouée en paramètre à la fonction getStr).

gilou

Modérateur
Modzilla

Justement, tu l'utilises alors que c'est une variable externe à ta fonction. Ta variable est cachée: c'est un paramètre de ta fonction (modifier sa valeur modifie le comportement de ta fonction), mais elle n'est pas déclarée dans la liste des paramètres de ta fonction.
C'est une mauvaise habitude de ne pas expliciter tous les paramètres d'une fonction. Sur un petit programme comme cela, ça semble anodin, mais avoir ce genre de pratique finit toujours par jouer des tours.

Tu pouvais soit déclarer

Code :

int getStr(char (*c)[MAXLGHT])
{
char temp;
int i = 0;
for(;;)
if((temp = getchar()) != '\n')
if(i < sizeof (*c))
(*c)[(isspace(temp)) ? i : i++] = temp;
else
i++;
else
break;
(*c)[i] = '\0';
return i;
}

et faire un appel i = getStr(&read);
C'est complexe, mais c'est la manière dont il faut déclarer le paramètre afin que sizeof retourne la taille effective du tableau.

ou bien tu peux faire avec le paramètre explicite:

Code :

int getStr(char c[], int maxlen)
{
char temp;
int i = 0;
for(;;)
if((temp = getchar()) != '\n')
if(i < maxlen)
c[(isspace(temp)) ? i : i++] = temp;
else
i++;
else
break;
c[i] = '\0';
return i;
}

et faire un appel i = getStr(read, MAXLGHT);

A+,

Message édité par gilou le 23-11-2012 à 00:05:15

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

gilou

Modérateur
Modzilla

Et en remplacement de ton gerStr, pour lire l'input utilisateur, tu peux sauvegarder cette fonction 'la plus blindée possible' dans ta bibliothèque de code perso:

Code :

int read_input(char *s, int n) {
int last = 0;
if (n > 0) {
char *p;
if ((p = fgets(s, n, stdin))) {
last = strlen(s) - 1;
if (s[last] == '\n') {
s[last] = '\0';
}
else {
scanf("%*[^\n]" );
getchar();
last = n - 1;
}
}
}
return last;
}

que tu appelles avec
char buffer[BUFSIZE];
.....
read_input(buffer, sizeof buffer);

et qui copiera dans buffer au plus les BUFSIZE-1 premiers caractères entrés par l'utilisateur, ajoute un \0 en dernière position si nécessaire, et nettoiera les caractères restant dans le buffer d'entrée. La valeur retournée est le nombre de caractères copiés dans buffer.

Note: la variante suivante

Code :

int read_input(char *s, int n) {
int last = 0;
if (n > 0) {
char *p;
if ((p = fgets(s, n, stdin))) {
last = strlen(s) - 1;
if (s[last] == '\n') {
s[last] = '\0';
}
else {
int m = 0;
scanf("%*[^\n]%n", &m);
getchar();
last = n + m - 1;
}
}
}
return last;
}

fait la même chose (au cas n = 0 près, qui n'a guère de sens), mais a pour valeur de retour le nombre de caractères tapés par l'utilisateur (ce qui permet de savoir s'il a dépassé la capacité autorisée).

A+,

Message édité par gilou le 23-11-2012 à 11:51:17

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

simius_computus

oh Gary boy

D'accord, j'ai compris. Merci :jap:

Faudra que je lise la doc sur la bibli standard, pour le moment je suis jamais sorti des printf et getchar

---------------
IWH --- Le forum de toute une génération : http://losersiv.1fr1.net (losers, sans-ami, dépressifs, allez on va faire cette merde)

Publicité

FORUM HardWare.fr

Programmation

Calculatrice notation scientifique

Sujets relatifs
Erreur Calculatrice	calculatrice textuelle
Systeme de notation	Mettre cours sur calculatrice
recuperer une police d une calculatrice	Notation romaine décroissante en langage C
calculatrice flottante en java	Accès à un array dans un objet / notation
Acheter une solution de type "notation des produits par le public"	lire un nombre en notation scientifique dans un fichier
Plus de sujets relatifs à : Calculatrice notation scientifique

Page générée en 0.396 secondes