Bonjour,
Il faudrait que tu nous dise tout "ce qui précède".
Sinon, comment veux-tu qu'on te réponde?

Bonjour,

La méthode de Newton permettant de calculer est basée sur la suite (u_n) définie par :
u₀ = A
u_n+1 = 0,5u_n + A/(2u_n)

La relation de récurrence peut aussi s'écrire :

Si on veut obtenir le résultat sous forme de fraction d'entiers, alors il faut séparer le numérateur (N) du dénominateur (D) :

On pose
On déduit :

On obtient alors 2 suites récurrentes, l'une pour le numérateur (N_n) et l'autre pour le dénominateur (D_n) :

  et  

  et  

À partir de là, l'algorithme est facile à écrire :

Début
   Lire A   (nombre dont on cherche la racine carrée)
   Lire n   (nombre d'itérations)
   N reçoit la valeur A
   D reçoit la valeur 1
   Pour k de 1 à n
      E reçoit la valeur N     (on range N dans E avant qu'il ne soit écrasé)
      N reçoit la valeur N²+AD²
      D reçoit la valeur 2ED
   Fin pour
   Afficher N et D
Fin

Sauf erreur

Remarque : dans mon algorithme, il faut distinguer les variables N et n, ce qui n'est pas possible dans tous les langages ...
      

@sanantonio312
Voici l'énoncé du Dm en entier mais il ne sert normalement pas à résoudre la dernière question sur l'algorithme :

A - Une fonction convexe sur un intervalle [a,b] si son graphe est situé en dessous de chacune de ses cordes. ce qui se traduit par l'inégalité de convexité suivante :
(,)  [a,b]2,t[0,1], f(t+(1-t))tf()+(1-t)f()

On suppose de plus que f est une fonction deux fois dérivable sur l'intervalle [a,b] et de dérivée seconde f" positive (au sens large).

1)En étudiant les variations de la fonction définie sur [a,b] par :
(x)=f(x)-((x-x0)f'(x0+f(x0))
Où x0  [a,b], montrer que le graphe de f est situé au dessus de ses tangentes.

2) En déduire que pour tout réels x0, x1, x2 de [a,b] vérifiant x1x0  x2, on a :
[f(x1)-f(x0)]/[1-x0][f'(x0)[f(x2)-f(x0)]/[2-x0]

3) Montrer alors que f est convexe
(Indication : pour tout réels ,  de [a,b], on pourras poser x0=t+(1-t), x1= et x2=)


PARTIE B - La méthode de Newton

Soit f une fonction deux fois dérivable, de dérivée seconde positive sur un intervalle [a,b], dont la dérivée f' ne s'annule pas et telle que l'équation f(x)=0 admette une unique solution [a,b].
prenons x0[a,b]. la tangente à la courbe représentative de f dans un repère du plan coupe l'axe des abscisses en un point x1.

1)Montrer que x1=x0-f(x0)/f'(x0).

2)On construit ainsi de proche en proche une suite (xn)vérifiant que pour tout entier naturel n :
xn+1=xn-f(xn)/f'(xn).

a) Montrer que f' est de signe constant sur [a,b].

On supposeras par la suite que f'0 sur [a,b]

b) Montrer que pour tout entier n1, xn.

c)Montrer que la suite (xn)n1 est décroissante et qu'elle converge vers l'unique solution de l'équation f(x)=0.

d)Application:
En utilisant la fonction x -> x^2 - a, avec a appartient à l'ensemble R+*, déterminer une suite qui converge vers racine de A.
(Donc j'ai réussi à répondre à la question mais c'est après que j'ai pas réussi)
A partir de ce qui précède, proposer un algorithme prenant en entrée un entier naturel A et donnant en sortie des valeurs approchées de Racine de A sous forme de fractions d'entiers

@patrice rabiller
Merci pour votre réponse bien très bien expliquée!! J'ai réussi à comprendre parfaitement votre raisonnement et j'ai fait l'algorithme sur algobox, tout fonctionne!
J'en demande peut-être de trop mais auriez-vous des valeurs pour vérifier la justesse de l'algorithme que j'ai rentré sur algobox?
A bientôt et merci encore pour votre réponse très rapide et très bien expliquée!

Pour vérifier sur un exemple, il suffit de choisir A=3 et N=3. Le résultat affiché par ma calculatrice est probant :
On remarque que le rapport N/D est très proche de .
La convergence est très rapide : il suffit de quelques itérations (moins de 6) pour obtenir au moins 10 chiffres après la virgule...
Cela dit, le programme pourrait être amélioré car la fraction obtenue est souvent réductible.

Voici mon algorithme sur agobox :

1   VARIABLES
2     A EST_DU_TYPE NOMBRE
3     N EST_DU_TYPE NOMBRE
4     D EST_DU_TYPE NOMBRE
5     E EST_DU_TYPE NOMBRE
6     m EST_DU_TYPE NOMBRE
7     k EST_DU_TYPE NOMBRE
8   DEBUT_ALGORITHME
9     LIRE A
10    LIRE m
11    N PREND_LA_VALEUR A
12    D PREND_LA_VALEUR 1
13    POUR k ALLANT_DE 1 A m
14      DEBUT_POUR
15      E PREND_LA_VALEUR N
16      N PREND_LA_VALEUR N^2+(A*D)^2
17      D PREND_LA_VALEUR 2*E*D
18      FIN_POUR
19    AFFICHER N
20    AFFICHER D
21  FIN_ALGORITHME

(j'ai remplacé le n par m)

et quand je mets A=3 et donc m=3 j'obtiens :
***Algorithme lancé***
Entrer A : 3
Entrer m : 3
1301728
***Algorithme terminé***
J'ai cherché où était le problème dans l'algorithme et impossible de voir ce qui cloche...

15      E PREND_LA_VALEUR N 
16      N PREND_LA_VALEUR N^2+(A*D)^2 
17      D PREND_LA_VALEUR 2*E*D

VARIABLES
  A EST_DU_TYPE NOMBRE 
  K EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE 
  X1 EST_DU_TYPE NOMBRE
  X2 EST_DU_TYPE NOMBRE
  F EST_DU_TYPE NOMBRE
  DF EST_DU_TYPE NOMBRE
  MSG EST_DU_TYPE CHAINE

DEBUT_ALGORITHME

  LIRE A 
  LIRE N 
  X1 PREND_LA_VALEUR A
  POUR K ALLANT_DE 1 A N
    DEBUT_POUR
    //--------------------------------------------------------
    //  F: Fonction F(X)   DF: Dérivée de F(X)
    //  Xn+1 = Xn - F(Xn)/F'(Xn)
    //--------------------------------------------------------
    F PREND_LA_VALEUR X1*X1 - A     
    DF PREND_LA_VALEUR 2*X1         
    X2 PREND_LA_VALEUR X1 - F/DF    
    MSG PREND_LA_VALEUR "X(" + K +") = " + X1
    AFFICHER* MSG
    X1 PREND_LA_VALEUR X2
    FIN_POUR 
  AFFICHER* "------------------------------------------------"
  MSG PREND_LA_VALEUR "==> X(" + N +") = " + X1
  AFFICHER* MSG
  MSG PREND_LA_VALEUR "RACINE(" + A +") = " + SQRT(A)
  AFFICHER* MSG
  	
FIN_ALGORITHME

À la ligne 16, il faut remplacer (A*D)^2 par A*D*D ou par A*(D^2)
En effet (A*D)^2 = A^2 * D^2 = A*A*D*D

@patrice rabiller
Ah oui belle faute d'étourderie de ma part!
J'ai changé et maintenant l'algorithme me donne ça :
***Algorithme lancé***
Entrer A : 3
Entrer m : 3
1553014976
***Algorithme terminé***
je ne vois pas du tout ce qui cloche…

Voici une version raccourcie...

VARIABLES
  A EST_DU_TYPE NOMBRE 
  K EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE 
  X1 EST_DU_TYPE NOMBRE
  X2 EST_DU_TYPE NOMBRE
  F EST_DU_TYPE NOMBRE
  DF EST_DU_TYPE NOMBRE
  MSG EST_DU_TYPE CHAINE

DEBUT_ALGORITHME

  LIRE A 
  LIRE N 
  X1 PREND_LA_VALEUR A
  POUR K ALLANT_DE 1 A N
    DEBUT_POUR
    F PREND_LA_VALEUR X1*X1 - A     
    DF PREND_LA_VALEUR 2*X1         
    X2 PREND_LA_VALEUR X1 - F/DF    
    X1 PREND_LA_VALEUR X2
    FIN_POUR 
  MSG PREND_LA_VALEUR "==> X(" + N +") = " + X1
  AFFICHER* MSG
  	
FIN_ALGORITHME

Bonjour LeDino,
Merci de m'aider aussi pour cet algorithme! Je l'ai donc fait sur algobox et eurêka, il fonctionne très bien!! J'obtiens :
***Algorithme lancé***
Entrer A : 3
Entrer N : 3
==> X(3) = 1.7321428571428572
***Algorithme terminé***
donc ce qui correspond bien à la valeur de N/D!
Merci infiniment à toi et à patrice rabiller pour avoir passer du temps à m'aider et à bien m'avoir expliqué et pas juste m'avoir donner le résultat!

L'énoncé stipule :

J'ajoute qu'il n'est nulle part question, dans l'énoncé, d'écrire l'algorithme dans le langage "Algobox" ... Quand on dit "écrire un algorithme", normalement ça veut dire "écrire en langage naturel" : le langage d'Algobox n'est certainement pas un langage naturel mais un code très précis avec une syntaxe rigoureuse (tout comme le basic, la pascal, le C, le Java et les centaines d'autres langages possibles).

Bonsoir Patrice,

Tu as parfaitement raison pour l'énoncé : je n'avais même pas remarqué qu'il demandait le résultat sous forme d'une fraction.

Du coup je vois aussi ce qui cloche dans la première version du programme de fromhell...
Le résultat est correct mais c'est juste l'affichage qui cloche :
il affiche à la suite N et D, sans séparation...
1301728  est en fait en réalité : 1301/728 = 1,7870...


Avec le calcul de fraction, l'algorithme est effectivement plus compliqué, puisqu'il faut gérer numérateur et dénominateur.
A partir des explication de Patrice, je préconise de gérer :
N1, D1 (représentant numérateur et dénominateur au rang n) et
N2, D2 (représentant numérateur et dénominateur au rang n+1).

VARIABLES
  A EST_DU_TYPE NOMBRE 
  K EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE 
  N1 esT_DU_TYPE NOMBRE
  N2 esT_DU_TYPE NOMBRE
  D1 esT_DU_TYPE NOMBRE
  D2 esT_DU_TYPE NOMBRE
  MSG EST_DU_TYPE CHAINE

DEBUT_ALGORITHME
  LIRE A 
  LIRE N 
  N1 PREND_LA_VALEUR A
  D1 PREND_LA_VALEUR 1
  POUR K ALLANT_DE 1 A N
    DEBUT_POUR
    N2 PREND_LA_VALEUR N1*N1 + A*D1*D1
    D2 PREND_LA_VALEUR 2*N1*D1
    D1 PREND_LA_VALEUR D2
    N1 PREND_LA_VALEUR N2    
    MSG PREND_LA_VALEUR N1 + "/" + D1 + " = " + N1/D1
    AFFICHER* MSG   
    FIN_POUR 
FIN_ALGORITHME

Je viens de faire cet algorithme et il fonctionne lui aussi parfaitement!
Merci beaucoup de votre aide!
Les algorithmes c'est simple mais une fois que tu as bien compris ^^