Inscription / Connexion Nouveau Sujet
Algorithme sur Algobox
Bonjour,
Ma prof de math m'a donné un algorithme sur Algobox à faire (plus détailler sur papier)
Soit U et V deux suites telles que :
- Un+1 = Un - 12/13 Vn
- Vn+1 = 12/13 Un + 5/13 Vn
- Tenter de déterminer expérimentalement la limite des deux suites
- Soit E une valeur très faible
- A partir de quelle valeur a t'on Un+1 - Un < E
- A partir de quelle valeur a t'on Vn+1 - Vn < E
Représenter le résultat
Si vous pouvez m'aider, piste, exemple...
Merci d'avance
Bonjour ,
Tu as donc deux suites qui seront matérialisées dans l'algorithme par deux variables u et v (pas d'indice, une seule variable prend successivement les valeurs U0, puis U1, puis U2 etc .. dans la seule et même variable u)
j'ai fait exprès de ne pas donner le même nom à la variable (u minuscule) et aux valeurs de la suite (U majuscule)
ce sont deux choses différentes.
Avec l'habitude et quand cette différenece est parfaitement claire, on peut tout à fait appeler la variable comme on veut, pourquoi pas U.
initialiser u et v par les valeurs U0 et V0 "en dur", ou mieux demandées par un "LIRE u"
Il te faut une boucle (pour, tant que au choix mais le mieux puisque tu cherches une condition valeur < E sera une boucle tant que)
dans cette boucle tu réalises les deux relations de récurrences données
piège : tu ne peux pas écrire
u PREND_LA_VALEUR u - 12*v/13
puis
v PREND_LA_VALEUR 12*u/13 + 5*v/13 car à ce moment u contient deja Un+1 et ne contient plus Un
tu dois donc "sauvegarder la valeur précédente" dans une variable supplémentaire up avant de modifier u
...
lances toi et essaye d'écrire quelque chose, Algobox ne mord pas.
Merci, je commence " à comprendre " très légèrement
-Variables
-- u EST_DU_TYPE NOMBRE
-- v EST_DU_TYPE NOMBRE
-Début
Jusque la c'est bon d'après tes explications? Mais maintenant je comprend pas ce que je dois faire.. 
Si quelqu'un pourrais un peu m'aider, c'est la première fois que je dois travailler sur Algobox et je suis un peu perdu..
Merci d'avance
C'est un bon début !!
j'ai pourtant donné pas mal d'infos sur la suite !!
tu dois déja initialiser ta suite, c'est à dire mettre la valeur de U0 et de V0 dans les variables u et v :
soit par un
u PREND_LA_VALEUR 12 (valeur numérique ici au hasard)
v PREND_LA_VALEUR 41 " "
en remplaçant ces valeurs par celles de l'énoncé s'il y en a
soit (mieux) par un
LIRE u
LIRE v
qui demandera à l'exécution ces valeurs
une suite n'est pas définie par sa seule formule de récurrence !
le comportement d'une suite dépend aussi des valeurs initiales !
ensuite eh bien tu fais une boucle
ici ce sera une boucle TANT_QUE
TANT_QUE on n'a pas fini
...
plutôt que de taper ça en mode éditeur dans Algobox, pour éviter les erreurs de frappe et de syntaxe le mieux est de lui faire générer la syntaxe directement par les boutons appropriés. "ajouter TANT_QUE" après avoir crée une nouvelle ligne.
reste à déterminer cette condition "on n'a pas fini"
on demande de s'arrêter quand Un+1 - Un < E
il va donc te falloir deux variables pour u comme j'avais déja suggéré
la valeur actuelle : variable u
la valeur précédente : variable up
au départ u est initialisée par U0 (valeur numérique)
il n'y a pas de valeur précédente mais il faut absolument mettre quelque chose au départ dans la variable up !! TOUTES les variables doivent être initialisées, tout au moins une valeur doit être mise dedans avant toute utilisation de cette variable.
on peut choisir de mettre u + 1000, pour être sûr que le test Un+1 - Un < E (E faible) soit faux
c'est à dire u - up < la valeur de E soit faux (sinon on s'arêterait immédiatement sans avoir rien calculé !)
le début du programme devient donc
variables u, v, up, vp des nombres
debut
lire u
lire v
up prend la valeur u + 1000
vp prend la valeur v + 1000
tant que abs(u-up) > E
up prend la valeur u
vp prend la valeur v
u prend la valeur ...
v prend la valeur ...
fin tant que
fin algo
l'astuce ici est la signification de "tant que", qui est comme en français
tant que l'exercice n'est pas fini je travaille
tant que |u - up| n'est pas < E je continue
|u - up| n'est pas < E se traduit par |u - up| 
E, simplifié ici en > E
c'est quasiment fini !
il reste quelques gadgets
syntaxe exacte de ALGOBOX comme je le disais utiliser les boutons pour faire ça propre
afficher quelque chose. Les valeurs de u et v à chaque boucle par exemple
mettre une sécurité en comptant les boucles (une autre variable n) pour éviter que la boucle tant que ne s'arrête jamais si la suite diverge
essaie de rédiger les bouts qui manquent.
Merci je continue d'avancer
Pour: u prend la valeur ... up - 12/13vp ?
v prend la valeur ... 12/13up + 5/13vp ?
Ce serait correct? Car pour moi c'est les seules valeurs dont je dispose.
Il faut que je définisse E aussi non?
OK pour la mise à jour de u et v dans la boucle, sauf la syntaxe
il n'y a pas de multiplication "implicite" en programation
tu dois mettre explicitement les symboles de multiplication : *
u prend la valeur up - 12/13*vp
et pour être vraiment sûr de ce que ça fait, ajouter même des parenthèses :
u prend la valeur up - (12/13)*vp
E bien sûr
ce doit être soit une valeur numérique (par exemple 0.001 "valeur très faible" est-il dit)
soit mieux une nouvelle variable E avec un "lire E"
ceci dit apparemment ta double suite diverge sauvagement
es tu certain des formules de récurrence ?
- Un+1 = Un - 12/13 Vn
- Vn+1 = 12/13 Un + 5/13 Vn
c'est
c'est vraiment ça exactement ??
Voici le sujet donné par la prof
Donc je déclare E en meme temps que u, up, v, vp?
Les limites c'est le +1000?
eh bè... tu vas avoir du mal à obtenir la limite des deux suites divergentes !
E, oui, tu déclares et tu "lis"/initialise en même temps que les autres
Les limites c'est le +1000?
je t'ai expliqué ce "+1000", c'est une valeur arbitraire quelconque pour s'assurer que |U0 - U-1| est suffisemment grand pour être > E et pour éviter que la boucle tant que ne s'arrête avant même d'être exécutée ne serait-ce qu'une seule fois.
dès que la boucle tant que s'exécute cette valeur est mise à la poubelle par le "up prend la valeur u" etc ... qui remplace la valeur initiale par cette nouvelle valeur (la première fois ce sera donc la valeur de U0, qui se trouve en ce moment dans u, et on calculera U1 dans u
à chaque boucle, en fin de boucle on aura up contient Un et u contient Un+1)
Il n'y a aucune "limite" dans cet algorithme
On cherche (vainement) à ce que la suite converge c'est à dire à ce que la différence de deux termes consécutifs devienne < E
cette recherche se poursuit pour l'instant "éternellement" puisque ça n'arrivera jamais !
(cela s'arrête par une erreur d'Algobox qui rale en disant "trop de boucles" ou "trop de valeurs affichées")
si on veut faire propre il faut ajouter une autre variable n par exemple
qu'on initialise à 0 (après tout, la valeur initiale c'est U0)
et qu'on incrémente de 1 dans la boucle (par un n prend la valeur n+1)
et dans le "tant que" on rajoute une condition sur n :
tant que abs(u-up)>E ET n < nombre de boucle maxi souhaité
tu mets ce que tu veux pour ce nombre maxi de boucles
mais ça n'a aucun rapport avec la valeur arbitraire de +1000 pour l'initialisation de U-1 (U indice -1, la valeur qui précède la valeur initiale U0 de la suite !!, juste un truc pour satisfaire Algobox et ses calculs, ça n'existe pas U-1)
et ça n'a aucun rapport avec une "limite" demandée pour les suites, qui serait la valeur vers laquelle tendrait Un quand n devient aussi grand qu'on veut (tend vers l'infini)
hélas je ne vois vraiment pas comment ces suites pouraient tendre vers quoi que ce soit. l'exo est de toute façon foireux.
Quoique, "tenter de" cela veut bien dire que ça peut échouer !
tu fais donc "comme si" en espérant une limite avec cet algo (qu'il s'arrête parceque pour un certain n Un+1 - Un serait < E)
et comme il ne s'arrête pas (tout au moins pas pour ce critère là), tu vas en conclure qu'on ne peut pas déterminer la limite de ces suites (car en fait elles n'en ont pas)
Oui, début impec.
"Lire n", pas vraiment. n au départ c'est 0
donc juste "n PREND_LA_VALEUR 0", ce n'est pas sensé être quelque chose qui varierait au gré des expérimentations, contrairement aux valeurs initiales U0 et V0 et à E (pas données dans l'énoncé, donc à choisir librement, donc à choisir à l'éxécution par les "LIRE")
ensuite l'algo fonctionne nickel mais ne dit rien
donc qu'en conclure ??
Il faudrait ajouter un afficher quelque chose (les valeurs de u et v par exemple 
)
J'essaie de faire tourner l'algo, mais il a l'air de tourner en rond.. Il m'affiche à la fin les valeurs de u et v que je rentre moi
tel que tu l'as mis il n'affiche rien du tout, normal.
la seule chose qu'il affiche c'est effectivement ce que tu as tapé, au moment où tu l'as tapé (c'est à dire avant qu'il ne calcule quoi que ce soit).
Au bout de 1000 boucles, il n'a rien affiché d'autre puisque tu n'as mis aucune instruction "AFFICHER" !!!
Il faudrait ajouter un afficher quelque chose (les valeurs de u et v par exemple)
moi il m'affiche ça, avec bien sûr un "AFFICHER" idoine dans la boucle !!
***Algorithme lancé***
Entrer u : 1
Entrer v : 1
Entrer E : 0.01
u[1] = 0.07692307692307687, v[1] = 1.3076923076923077
u[2] = -1.1301775147928996, v[2] = 0.57396449704142
u[3] = -1.6599908966772874, v[3] = -0.8224852071005919
u[4] = -0.9007737824305873, v[4] = -1.8486397535100314
u[5] = 0.805662913117134, v[5] = -1.5424987812859388
u[6] = 2.229507941996462, v[6] = 0.15042008084430103
u[7] = 2.090658636601723, v[7] = 2.115861208321465
u[8] = 0.13755598276652425, v[8] = 2.743631513909846
u[9] = -2.395026953150256, v[9] = 1.182217643288271
u[10] = -3.486304777724045, v[10] = -1.7560950170278247
...
u[490] = 1.7421205804260014e+22, v[490] = 4.91512179745438e+22
u[491] = -2.7949149249165035e+22, v[491] = 3.498542765567994e+22
u[492] = -6.0243390162100365e+22, v[492] = -1.2343280977813898e+22
u[493] = -4.8849592336426e+22, v[493] = -6.035669898725184e+22
u[494] = 6.864283651806473e+21, v[494] = -6.830604638256702e+22
u[495] = 6.991601877417603e+22, v[495] = -1.9935294468550572e+22
u[496] = 8.831782905283809e+22, v[496] = 5.687044253441227e+22
u[497] = 3.5822035944149833e+22, v[497] = 1.0339739702354756e+23
u[498] = -5.962171515450945e+22, v[498] = 7.283472434211813e+22
u[499] = -1.2685376839338772e+23, v[499] = -2.7022073857194047e+22
u[500] = -1.0191031560213168e+23, v[500] = -1.2748889153897099e+23
***Algorithme terminé***
(j'arrête à 500 c'est bien suffisant pour voir que la suite diverge, on en est déja à des nombres de l'ordre de 1023 !
si on insiste avec 1000 termes il rale en disant qu'on lui demande d'afficher trop de données et avec 10000 termes il rale parce que ça dépasse les capacités de calcul (nombres trop gigantesques))
ça y est j'ai trouvé ton erreur
relis bien attentivement mon post de 21h19 sur l'explication de la condition du tant que, hein.
"tant que", c'est "tantque on n'a PAS fini"
pas "tant que on a atteint ce qu'on voulait" !!
tel que tu l'as fait ta boucle est éxécutée 0 fois
puisque 1000 < E est faux. (au départ abs(u - up) = 1000)
pour obtenir des sorties "formattées" (du texte mélangé avec des valeurs de variables) deux méthodes :
la lourde :
un paquet de AFFICHER message
et de AFFICHER variable
l'efficace :
utilisation d'une variable chaine
ainsi j'ai déclaré une variable chaine msg
msg EST_DU_TYPE CHAINE
et je fais :
msg PREND_LA_VALEUR "u["+n+"] = "+u+", v["+n+"] = "+v
AFFICHER* msg
(en mode editeur AFFICHER* veut dire que la case "retour à la ligne" est cochée)
la syntaxe est un peu compliquée, mais ça vaut le coup !
"u[" est une chaine de caractères
on "concatène" (accolle) à cette chaine par + le contenu de la variable n (qui comme par hasard est l'indice de boucle !)
puis on concatène au bout de ça la chaine "] = "
puis on concatène le contenu de la variable u etc ...
faut juste faire attention et pas se mélanger les pinceaux entre ce qui est chaine de caractères et ce qui est variables
on peut faire des truc plus sioux encore et écrire des
msg PREND_LA_VALEUR "u["+n+"] = "+u+", u["+(n-1)+"] = "+up
qui affichera si par exemple à ce moment n vaut 97 :
U[97] = 36034.414137029926, U[96] = 15957.443120026324
on a fait un calcul de la valeur n-1 dans l'instruction de calcul de la chaine msg !
enfin on peut mettre des caractères spéciaux dont \n qui veut dire aller à la ligne
(en fait tout ça c'est parce que ALGOBOX est basé sur JavaScript, c'est de la syntaxe JavaScript)
Merci beaucoup, normalement tu as obtenu ce que ma prof veut, merci de ton implication dans mes soucis 
mathafou 
Annuler
connectez vous