Algorithme écrit pour le logiciel éducatif Algobox

******************************************
Recherche du rang n à partir duquel la série 1+x/1+x^2/2!+x^3/3!+... est proche de exp(x) avec une précision donnée.
******************************************

1   VARIABLES
2     msg EST_DU_TYPE CHAINE
3     p EST_DU_TYPE NOMBRE
4     n EST_DU_TYPE NOMBRE
5     factn EST_DU_TYPE NOMBRE
6     xn EST_DU_TYPE NOMBRE
7     S EST_DU_TYPE NOMBRE
8     x EST_DU_TYPE NOMBRE
9     ex EST_DU_TYPE NOMBRE
10    err EST_DU_TYPE NOMBRE
11  DEBUT_ALGORITHME
12    msg PREND_LA_VALEUR "entrer la précision voulue (par exemple entrer 5 pour une précision de 10^(-5) : "
13    AFFICHER msg
14    LIRE p
15    AFFICHER " "
16    err PREND_LA_VALEUR pow(10,-p)
17    msg PREND_LA_VALEUR "précision demandée : " + err
18    AFFICHER msg
19    msg PREND_LA_VALEUR "Entrer la valeur réelle x pour laquelle on veut établir la précision demandée : "
20    AFFICHER msg
21    LIRE x
22    AFFICHER " "
23    msg PREND_LA_VALEUR "x=" + x
24    AFFICHER msg
25    ex PREND_LA_VALEUR exp(x)
26    msg PREND_LA_VALEUR "exp(x)=" + ex
27    AFFICHER msg
28    n PREND_LA_VALEUR 0
29    factn PREND_LA_VALEUR 1
30    xn PREND_LA_VALEUR 1.0
31    S PREND_LA_VALEUR 1.0
32    TANT_QUE (ex-S>err) FAIRE
33      DEBUT_TANT_QUE
34      n PREND_LA_VALEUR n+1
35      xn PREND_LA_VALEUR xn*x
36      factn PREND_LA_VALEUR factn*n
37      S PREND_LA_VALEUR S + xn / factn
38      msg PREND_LA_VALEUR "S=" + S
39      AFFICHER msg
40      FIN_TANT_QUE
41    msg PREND_LA_VALEUR "le rang trouvé est " + n
42    AFFICHER msg
43  FIN_ALGORITHME

Exemple de résultat d'exécution
***Algorithme lancé***
entrer la précision voulue (par exemple entrer 5 pour une précision de 10^(-5) :  
précision demandée : 0.00001
Entrer la valeur réelle x pour laquelle on veut établir la précision demandée :  
x=2
Math.exp(x)=7.38905609893
S=3
S=5
S=6.33333333333
S=7
S=7.26666666667
S=7.35555555556
S=7.38095238096
S=7.38730158731
S=7.38871252205
S=7.388994709
S=7.38904601572
S=7.38905456684
le rang trouvé est 12

***Algorithme terminé***

Merci je vais essayer, mais tu est sur

là tu es vexant

Désole merci

aurai tu un autre exemple please avec - quelque chose

je ne comprends pas ta demande.
avec - quelque chose
tu veux dire un nombre négatif ?

***Algorithme lancé***
entrer la précision voulue (par exemple entrer 5 pour une précision de 10^(-5) :

précision demandée : 0.00001
Entrer la valeur réelle x pour laquelle on veut établir la précision demandée :

x=-2
Math.exp(x)=0.135335283237
S=-1
S=1
S=-0.333333333333
S=0.333333333334
S=0.0666666666673
S=0.155555555556
S=0.130158730159
S=0.136507936508
S=0.135097001764
S=0.135379188713
S=0.135327881995
le rang trouvé est 11

***Algorithme terminé***

Attention, je me rends compte que je ne t'avais pas transmis la dernière version de mon algorithme, il manque une fonction ABS() dans le test du tant que

voilà la dernière version :

VARIABLES
msg EST_DU_TYPE CHAINE
p EST_DU_TYPE NOMBRE
n EST_DU_TYPE NOMBRE
factn EST_DU_TYPE NOMBRE
xn EST_DU_TYPE NOMBRE
S EST_DU_TYPE NOMBRE
x EST_DU_TYPE NOMBRE
ex EST_DU_TYPE NOMBRE
err EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
msg PREND_LA_VALEUR "entrer la précision voulue (par exemple entrer 5 pour une précision de 10^(-5) : "
AFFICHER* msg
LIRE p
AFFICHER* " "
err PREND_LA_VALEUR pow(10,-p)
msg PREND_LA_VALEUR "précision demandée : " + err
AFFICHER* msg
msg PREND_LA_VALEUR "Entrer la valeur réelle x pour laquelle on veut établir la précision demandée : "
AFFICHER* msg
LIRE x
AFFICHER* " "
msg PREND_LA_VALEUR "x=" + x
AFFICHER* msg
ex PREND_LA_VALEUR exp(x)
msg PREND_LA_VALEUR "exp(x)=" + ex
AFFICHER* msg
n PREND_LA_VALEUR 0
factn PREND_LA_VALEUR 1
xn PREND_LA_VALEUR 1.0
S PREND_LA_VALEUR 1.0
TANT_QUE (ABS(ex-S)>err) FAIRE
DEBUT_TANT_QUE
  n PREND_LA_VALEUR n+1
  xn PREND_LA_VALEUR xn*x
  factn PREND_LA_VALEUR factn*n
  S PREND_LA_VALEUR S + xn / factn
  msg PREND_LA_VALEUR "S=" + S
  AFFICHER* msg
FIN_TANT_QUE
msg PREND_LA_VALEUR "le rang trouvé est " + n
AFFICHER* msg
FIN_ALGORITHME

bonjour dhalte
ayant moi même le même problème avec cette algorithme,peut tu m'expliquer à quoi correspondent les variables que tu a utilisées car je ne le comprends pas même en cherchant bien...

merci encore dhalte

à dracaufeux

msg sert à afficher des messages
-------------
p pour définir qui sera la précision recherchée
-------------
ex est la valeur exacte (à la précision de la machine) de
cet algorithme n'a pas pour but de calculer exp(x), mais d'estimer combien de boucles il faudrait faire pour approcher la valeur exacte de exp(x)

la valeur réputée exacte est donnée par la machine
l'algorithme compare cette valeur exacte avec la somme qu'on calcule de plus en plus précisément à chaque boucle.
-------------
err est l' "erreur",
ça m'évite de laisser trainer dans la condition tant que l'expression recalculée à chaque boucle
tant que abs(S-ex)>10^(-p)
je préfère écrire
tant que abs(S-ex)>err
-------------
n pour compter les boucles faites
-------------
factn est n! que je calcule à chaque boucle, plutôt que d'appeler une fonction fact(n) toute faite
en effet,
au début factn <- 1 qui est 0!,
puis factn <- 1*1 qui est 1!,
puis factn <- 1*2 qui est 2!,
puis factn <- 2*3 qui est 3!,
puis factn <- 2*3*4 qui est 4!, etc.
-------------
x est la valeur réelle pour laquelle on veut calculer la somme 1+x/1!+x²/2!+...
-------------
xn est la puissance et là aussi, de la même manière je la calcule au fur et à mesure en multipliant à chaque boucle an par x
donc si à la boucle k, xn vaut , à la boucle suivante, k+1, xn vaudra
-------------
S est la somme 1+x/1!+x²/2!+... que je complète à chaque boucle en lui ajoutant le nouveau terme , c'est à dire xn/factn

merci c'est surtout le msg en CHAINE que je ne comprenais  pas ^^

donc en fait lorsque tu écris msg tu fait "AFFICHER MESSAGE" dans algobox c'est bien sa ?

car c'est la multitude de message qui rend confus même le meilleur élève de S (que je ne suis pas d'ailleurs)
(désolée de la multitude de post mais je ne trouve pas de commande éditer sur ce forum)

non, c'est pas sa, c'est ça

AFFICHER xxx
affiche le contenu de la variable xxx et reste sur la même ligne

AFFICHER "coucou"
affiche coucou  et reste sur la même ligne

quand on rajoute l' * à AFFICHER, on demande à Algobox de rajouter un retour à la ligne

si la variable x contient 3 et qu'on veut afficher le message
ceci vaut 3

on peut le faire de deux manières
AFFICHER "ceci vaut "
AFFICHER* x

ou alors
msg PREND_LA_VALEUR "ceci vaut " + x
AFFICHER* msg

quand on ajoute des chaînes et des nombres, comme "ceci vaut " + x
Algobox concatène les chaînes avec la représentation textuelle des nombres.

ah .....
moi pour aller à la ligne je ne met pas d'astérixe mais je coche la case retour à la ligne c'est normal ?
exemple:je veut a la fin d'une algorithme quelconque faire afficher mon résultat appelé n

je clique sur AFFICHER VARIABLE ,puis je choisis n puis ensuite je peut cocher la case retour à la ligne si besoin est

c'est normal ?

oui

il y a deux modes de saisie :
le mode avec boîtes de dialogue, où tu coches une case pour le retour à la ligne
le mode saisie directe, où tu ajoutes l'étoile pour faire la même chose

va voir dans le menu : Edition / Mode d'édition

mais sauvegarde ton travail avant !

et quand tu écris  AFFICHER " "  qu'est ce que cela veut dire ?

j'écris AFFICHER* " "

c'est une manière de faire faire un saut à la ligne après une saisie de valeur

je veux bien répondre à tes question, mais fais donc aussi tes essais dans Algobox directement, ce sera plus formateur...

D'accord merci je comprends beaucoup mieux et désormais je vais relire scrupuleusement le manuel
Je ne savais pas qu'il existait 2 mode deux modes de saisie car quand je clique sur édition en haut , il y a juste écris
copier ligne
coller ligne
couper ligne
il n'y a pas écrit mode d'édition
Je m'excuse de ne pas avoir compris ce que tu disais la prochaine fois j'essaierais de m'habituer à ce style pour comprendre ce que d'autres écrivent

je viens de voir que ne nouvelle version de Algobox avaient été publiés,expliquant l'absence de mode d'édition en haut
merci encore

alors ta version devait vraiment dater, parce que les deux modes d'édition existent depuis plusieurs années déjà, depuis que je l'utilise en fait...

Et bien ma fois ma version je l'utilise depuis 2 ans , depuis la seconde donc ^^
et comme je ne savais pas qu'il exister 2 modes, je ne comprenait pas ce que tu écrivais
merci encore de ta patience

comment avoir un arrondi à 10^-5 comme 0.12356955= 0.12357

plus précisément en p

0.12356955= 0.12357

n'écris jamais ça dans une copie de maths

à la rigueur :

je ne comprends pas ta question :

comment avoir un arrondi à

comme d'habitude, tu gardes les quatre premières,
la cinquième si les suivantes donnent un nombre entre 0 et 0.5
la cinquième + 1 sinon

c'est bien, c'est ce que tu as fait dans ton exemple, félicitations, mais alors je répète :
je ne comprends pas ta question.

je veux juste savoir comment faire un arrondi au cinquième chiffre après la virgule dans l'algorithme car je l'ai fais à la main et je trouve pour x=-2, on a n=13

pow(10,-p)*round(x*pow(10,p))

on le met a quel endroi

mais je ne sais pas ce que tu veux en faire, voyons

avec si peu de renseignements, il n'y a que Mme Irma qui peut t'aider.

je voudrai arrondir les résultats de s au cinquième chiffre après la virgule.

surtout pas,

pour que l'algorithme garde un sens, c'est à dire comparer la valeur calculée par la somme à la valeur fournie par l'ordinateur, il faut conserver la plus grande précision possible, donc ne jamais arrondir le calcul en cours.

x=-2
Math.exp(x)=0.135335283237 environ = 0.13534
S=-1
S=1
S=-0.333333333333
S=0.333333333334 environ = 0.33333
S=0.0666666666673 environ = 0.06667
S=0.155555555556 environ = 0.15556
S=0.130158730159 environ = 0.13016
S=0.136507936508 environ = 0.13651
S=0.135097001764 environ = 0.1351
S=0.135379188713 environ = 0.13538
S=0.135327881995 environ = 0.13532

donc il ne faut pas arrondir c'est ça même si avec n=13 c'est plus proche

imagine que le résultat exact soit 1.4
et que tu arrondisses à 0 décimales

ton résultat arrondi sera 1

maintenant, ta marge est de 0.5

imagine qu'au rang 12, tu obtiennes 0,51 : il te semblera que tu es proche du résultat (écart 1-0.51<0.5), alors qu'en réalité tu es encore à (1.4-0.51>0.5)

si au rang 15 tu obtiens 0.91, ton écart avec le résultat réel sera alors (1.4-0.91) et là, tu es à l'intérieur de ta marge d'erreur
alors que ton arrondi t'aura fait choisir le rang 12 où l'écart réel est encore > 0.5

c'est encore pire si tu arrondis le résultat calculé à l'intérieur de la boucle.

merci je vient de comprendre

Je viens de me rendre compte que nous avons oublier de rajouter une donnée dans l'énoncé
-Pour calculer xⁿ utiliser pow(x,n) et pour calculer factorielle de n ou n! utiliser ALGOBOX_FACTORIELLE(n)

je pense que cette condition ne changerai que la ligne 37 de ton algorithme avec S=S+(xn/ALGOBOX_FACTORIELLE(n))
mon raisonnement est-l cohérent ou est-ce que cette donnée change radicalement la base du programme ?

essaie les deux versions et fais-toi une idée personnelle



allez, je suis vache

tu peux alors supprimer la variable factn et tout ce qui y a affaire, puisqu'elle servait justement à calculer cette factorielle à chaque boucle.

tu peux supprimer xn et son calcul, puisqu'elle servait justement à calculer cette puissance à chaque boucle, et remplacer son utilisation par pow(x,n)

  xn PREND_LA_VALEUR xn*x
  factn PREND_LA_VALEUR factn*n
  S PREND_LA_VALEUR S + xn / factn
devient
  S PREND_LA_VALEUR S + pow(x,n) / ALGOBOX_FACTORIELLE(n)


mais je préfère ma solution.

Le temps que tu réponde j'avais déjà testé j'ai compris ma leçon
en version normal cela m'a donner ceci (j'ai légèrement changer le nom des variables)

1 VARIABLES
2 P_HQ EST_DU_TYPE NOMBRE
3 N_HQ EST_DU_TYPE NOMBRE
4 XPN_HQ EST_DU_TYPE NOMBRE
5 UN_HQ EST_DU_TYPE NOMBRE
6 X_HQ EST_DU_TYPE NOMBRE
7 ex_HQ EST_DU_TYPE NOMBRE
8 ER_HQ EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 AFFICHER "Choisir la précision "
11 LIRE P_HQ
12 ER_HQ PREND_LA_VALEUR pow(10,-P_HQ)
13 AFFICHER "précision souhaité: "
14 AFFICHER ER_HQ
15 AFFICHER "Entrez a valeur de x "
16 LIRE X_HQ
17 AFFICHER "x= "
18 AFFICHER X_HQ
19 ex_HQ PREND_LA_VALEUR exp(X_HQ)
20 AFFICHER "la valeur de exp(x) est de "
21 AFFICHER ex_HQ
22 N_HQ PREND_LA_VALEUR 0
23 XPN_HQ PREND_LA_VALEUR 1,0
24 UN_HQ PREND_LA_VALEUR 1,0
25       TANT_QUE (abs(ex_HQ-UN_HQ)>ER_HQ) FAIRE
26        DEBUT_TANT_QUE
27        N_HQ PREND_LA_VALEUR N_HQ+1
28        XPN_HQ PREND_LA_VALEUR XPN_HQ*X_HQ
29        UN_HQ PREND_LA_VALEUR UN_HQ+(XPN_HQ/ALGOBOX_FACTORIELLE(N_HQ))
30        AFFICHER "U(n)= "
31        AFFICHER UN_HQ
32        FIN_TANT_QUE
33 AFFICHER "Le rang n0 trouvé est de "
34 AFFICHER N_HQ


Pour x=2 le résultat obtenu est n=12 et pour x=-2 on a n=11

merci beaucoup

35 FIN_ALGORITHME

Apparemment l'algorithme marche ^^
j'ai bien réussi à transcrire dans le mode normal d'édition normal que j'utilise habituellement
j'espère juste que des petits malin de ma classe qui ne cherchent jamais leurs exercices ne chercherons pas à copier bêtement

PS : dans l'algorithme les _HQ c'est pour que mon prof sache que c'est le mien et c'était obligé

merci de ton soutien et de nous avoir appris à nous deux beaucoup de choses (en tout cas dans mon cas)

tu n'es pas partageux ? Pourtant j'ai quand même fait le plus gros du travail, tu ne devrais pas te l'approprier ainsi égoïstement.

je suppose que les HQ sont tes initiales

celui qui s'en sort en magouillant, en trichant, en recopiant, n'a pas ma sympathie, mais dans notre monde pas très reluisant, il a peut-être un bel avenir devant lui. beurk.

a tchao

je ne cherche absolument pas à me l'approprier je sais pertinemment que sans toi on en serait surement encore à comprendre l'énoncé

je veux bien te croire

ce qui m'avait surpris était ta remarque