salut

quand tu découpe l'arc de la courbe en n petits arcs tu approximes la longueur de chaque petits arcs d'extrémités et par la longueur du segment que tu sais calculer depuis le collège (car tu connais les coordonnées de ces points)

...

Bonjour,

un première remarque fondamentale : bien comprendre le role des parenthèses, de la priorité des opérations, pour écrire correctement les formules
par exemple
l'amplitude p = b-a/N

ce qui veut réellement dire ce qui est faux

c'est qui s'écrit p = (b-a)/N les parenthèses étant absolument obligatoires

bon revenons à l'exo proprement dit

ce que l'on cherche à faire c'est de remplacer la courbe par une ligne brisée
et calculer ainsi une valeur approchée comme somme de segments de droite.



(bon j'ai appelé P_k mes points au lieu de A_k de l'énoncé je ne vais pas refaire le dessin)

on la découpe donc en morceaux de largeur p =(b-a)/N, N étant le nombre de morceaux que l'on veut.
et on calcule chacun des P_kP_k+1 (Pythagore) et on en fait la somme

ce calcul et cette somme de proche en proche se faisant donc dans une boucle
"pour k de 1 à N"

Merci pour la réponse mais je ne comprends pas bien cette histoire de Pythagore

Par exemple pour calculer AP1, je devrais faire ça ?

Euh, je voulais écrire , pardon

oui, malgré tes démêlés avec LaTeX

et de façon générale chacun des segments



nota : (b-a)/N = p est calculé une fois pour toutes.
valable aussi pour en appelant

c'est cette formule qui devra être codée dans la boucle "pour k"
de façon peut être un peu plus propre que ce truc laid, avec quelques variables intermédiaires

D'accord! Voilà un bout de mon algorithme :
Entrée :
Saisir a, b, n
L prend la valeur 0
P prend la valeur (b-a)/N
Pour k allant de 1 à N
x1 prend la valeur a+kp
x2 prend la valeur a+(k+1) p

Là je bloque un peu comment puis-je exprimer f(x1) et f(x2) dans mon algorithme?
Je voulais assigner par ex B et C respectivement pour f(x1) et f(x2) puis :
L prend la valeur
Fin pour
Afficher L
Fin

les bornes de la boucles k ne sont pas bonnes ...

écrit simplement ensuite

b prend la valeur ...
c prend la valeur ...

où ... calcule f(...) et f(...)

attention qu'il y a déja une variable qui s'appelle b
et que la différence entre b et B n'est pas forcément garantie, et de plus risque de confusion humaine
donc utiliser une autre lettre évitera des risques d'erreur.

la fonction f() n'est pas précisée dans l'exo

donc dans l'algorithme on la laisse sous la forme f(..) : f(x1), f(x2) écrits comme ça.

de plus il ne s'agit pas de calculer les valeurs de L (de chaque segment) pour les mettre à la poubelle lors du calcul du segment suivant
mais surtout d'en faire la somme !!

donc

L prend la valeur racine de trucmuche

n'est pas bon
L ne contiendrait à chaque instant que la longueur du seul segment calculé en dernier, et pas la somme de tous les segments deja calculés.
(de sorte que à la fin quand on sort de la boucle ce soit la somme de tous les segments tout court)

Vous voulez dire que je dois créer une boucle pour pour L ≈ A0A1 + A1A2 + A2A3 + ⋯ + An−1An  ?
Mais je ne comprends pas comment l'utiliser avec la formule qu'on a déterminé

la boucle elle est sur k
elle est déja là

c'est l'instruction L prend la valeur

qui est fausse
comme déja dit elle ne met dans L que une seule valeur d'un seul segment : le dernier calculé à cet instant
alors que on doit mettre dans L le cumul de toutes les valeurs précédentes


c'est à dire

L prend la valeur L+
on ajoute à la somme le dernier calcul


par exemple avec 4 segments (N = 4)
avec l'instruction fautive si on déroule le programme :

k = 1
L prend la valeur A0A1 (AA1)
k = 2
L prend la valeur A1A2 (le calcul précédent est mis à la poubelle)
k = 3
L prend la valeur A2A3 (idem)
k=4
L prend la valeur A3A4 (A3B)
terminé
L contient la seule valeur du dernier segment, pas la longueur totale

avec le cumul :
L prend la valeur 0
k=1
L prend la valeur L + A0A1 = 0 + A0A1 = A0A1
k=2
L prend la valeur L + A1A2 = A0A1+A1A2
k=3
L prend la valeur L + A2A3 = (A0A1+A1A2) + A2A3 = A0A1+A1A2+A2A3
k=4
L prend la valeur L + A3A4 = (A0A1+A1A2+A2A3) + A3A4 = A0A1+A1A2+A2A3+A3A4
terminé

L contient la somme des segments c'est à dire la longueur totale.

Merci de m'avoir expliqué
Si je comprends bien mon algorithme donne :

Saisir a, b, n
L prend la valeur 0
P prend la valeur (b-a)/N
Pour k allant de 1 à N
x1 prend la valeur a+kp
x2 prend la valeur a+(k+1) p
E prend la valeur f(x1)
D prend la valeur f(x2)
L prend la valeur L + \sqrt{(P)^2+(E-D)^2}
Fin pour
Afficher L
Fin

presque

car

OK d'accord, donc pour cet algorithme :

Saisir a, b, n
L prend la valeur 0
P prend la valeur (b-a)/N
Pour k allant de 1 à N-1
x1 prend la valeur a+kp
x2 prend la valeur a+(k+1) p
E prend la valeur f(x1)
D prend la valeur f(x2)
L prend la valeur L + \sqrt{(P)^2+(E-D)^2}
Fin pour
Afficher L
Fin

Pour la question suivante
"2°)

a. Ecrire le programme Ti correspondant.

b. Donner une valeur approchée de L avec f: x ↦ x2, I = [0 ; 2] et pour n = 100 , puis n = 1000

puis n = 20 000"

J'ai défini f(x) = x^2 sur Y1
tapé sur TI le programme :
Input "A=", A
Input "B=", B
Input "N=", N
0 => L
(B-A)/N => P
For (K,0,N-1)
A+ K * P => X1
A +( K +1 ) * P => X2
Y1(X1) => E
Y1(X2) => D
L + => L
End
Disp L
End

Mais la calculatrice m'indique une erreur

Pour k allant de 0 à N-1 * pardon

je pense que c'est ton Y1(X1) pour calculer f(X1)
de plus tu n'as évidemment pas tapé tel quel
un problème de parenthèses ?


mais je ne suis pas spécialiste de la TI ...
vu que c'est exclusivement un problème de syntaxe et de frappe.

le programme me semble correct (syntaxiquement) pourtant

mais c'est simplement x1 et x2 qui ne vont pas ... variables non définies

remplacer

c'est vrai que le programme utilise un peu trop de variables "un peu inutiles" et remplacer X1 et X2 par une seule variable X1 (renommée C) en calculant l'autre par C + P au seul endroit où on en a besoin est judicieux
en plus du changement de noms de variables qui n'ont pas le droit de s'appeler X1 et X2 sur une TI apparemment

la multiplication des variables est utile pour exclusivement :

- aérer le calcul, et le rendre plus lisible (plutôt que de tout mettre directement dans une seule grosse formule de L)
- faciliter la mise en point en affichant les calculs intermédiaires lors d'une exécution pas à pas
- réutiliser plusieurs fois la valeur calculée précédemment sans la recalculer plusieurs fois

ainsi f(x2) est recalculé à la boucle suivante en tant que f(x1) (c'est le même point ! l'extrémité du segment devient l'origine du segment suivant)
on pourrait ainsi économiser peut être le calcul de f(x) fait chaque fois en double

mais de toute façon ici on ne cherche pas à grappiller quelques millièmes de secondes de recalcul inutile
le principal étant d'avoir un programme qui marche
même s'il n'est ni élégant ni d'efficacité optimisée.

En effet c'était une erreur de parenthèse!
Merci de votre aide