Forum de mathématiques - Bibm@th.net

Blis3

Invité

Polynome

Bonjour,

J'aimerais avoir de l'aide pour cet exercice :

Soit m un réel positif ou nul. Pour tout réel x, on pose P_m(x)=x^3+mx²+1.

Ecrire une fonction informatique qui recevant m et un entier n, renvoie une valeur approchée de l'unique racine réelle de P notée r(t) à 10^-n près.

J'ai vraiment du mal avec l'écriture de cet algorithme (via Python). Je partirai sur un schéma de Newton mais j'ai du mal à démarrer.

def polynome(m,x):
    return(x**3+m*x**2+1)

def polynome_derivee(m,x):
    return(3*x**2+2*m*x)

def approchee(m,n):
    r=[t]
    for k in range(n):
        while r>10**(-n):
            r=r+[r[k]-polynome(m,r[k])/polynome_derivee(m,r[k])]
    return(r)

Dlzlogic

Banni(e)

Inscription : 25-04-2016

Messages : 461

Re : Polynome

Bonsoir,
A mon avis, la première étape consiste à écrire l'algorithme.
Le code viendra ensuite, et cela dépend du langage.
Bon travail.

Blis3

Invité

Re : Polynome

bonsoir,
en fait ma question a été mal posée car pour moi algorithme c'est directement l'écriture du code en langage python...et c'et pour ça que je bloque

Dlzlogic

Banni(e)

Inscription : 25-04-2016

Messages : 461

Re : Polynome

Petite précision linguistique indispensable : on appelle algorithme une suite logique d'actions, écrites dans un langage compréhensible par tout le monde, en l'occurrence en français, pour détailler un problème et arriver à sa solution.
Je suis sûr que si vous écrivez l'algorithme, vous n'aurez aucune difficulté à le traduire dans votre langage informatique préféré, apparemment le Python.

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : Polynome

Bonjour,

Je rejoins Dizlogic : c'est une erreur de te lancer directement dans la rédaction du code...
Etablis d'abord ton "cahier des charges"...
Question :
As-tu déjà encadré ta solution  entre deux entiers ?

renvoie une valeur approchée de l'unique racine réelle de P notée r(t) à 10^-n près.

Je pars du principe que l'écart entre l'ancienne valeur de de r(t) et la nouvelle, dans ta boucle, doit être inférieur à 10^-n.

Ceci posé, si n=40, tu fais quoi ? Avec les moyens standard, c'est impossible...
Tu dois recourir au module decimal :
https://docs.python.org/3/library/decimal.html
Des exemples d'emploi de ce module :
http://python.jpvweb.com/mesrecettespyt … th_decimal

Maintenant j'en viens au nœud du problème.

l'unique racine réelle de P

Il est dit m>=0.
Supposons que je choisisse m = -2
Oui, parce que j'ai donc : [tex]P_{-2}(x)=x^3-2x^2+1[/tex]
Et puisque  [tex]P_{-2}(x)=x^3-2x^2+1=(x-1)(x^2-x-1)[/tex]
Ses racines réelles sont au nombre de 3 :
[tex]x_1=1,\;x_2=\frac{1-\sqrt 5}{2},\;x_3=\frac{1+\sqrt 5}{2}[/tex]

Il n'y a effectivement qu'une solution réelle si [tex]m\geqslant 0[/tex]
Moyennant quoi, même si m<0, avec ton code modifié a minima trouve [tex]x_3[/tex] assez vite...
Donc tu n'es pas loin de la solution :

Valeur approchée de r(t) : 1.6180339887498953

Ton code.
r=[t]
Qu'est-ce que t pour toi et quelle est sa valeur de t ?
Supposons qu'on ait la réponse...
Qu'est-ce que r, si r=[t] ? Réponse : une liste a un élément...
Et si tu essaies d'itérer sur r, tu risques de t'attirer un magnifique message d'erreur...

r=r+[r[k]-polynome(m,r[k])/polynome_derivee(m,r[k])]
Pour moi, c'est bien compliqué.
D'abord en Python on peut simplifier l'écriture r=r+a  en r+=a
Ensuite qu'est-ce [r[k]-polynome(m,r[k])/polynome_derivee(m,r[k])] ?
Réponse : une liste !
Une liste n'a d'intérêt que si on veut stocker différentes valeurs... Est-ce la cas ?  Te l'a-t-on demandé ?
Donc, tu additionnes deux listes r + [] ce qui n'en fait qu'une seule, r...
Et tu accèdes
N'utilise que des nombres r (sauf si on t'a expressément de stocker toutes les valeurs approchant la racine...)
Dans ce cas, tu écris (c'est plus simple à lire) :
r=r-polynome(m,r)/polynome_derivee(m,r]) qui devient r-=polynome(m,r)/polynome_derivee(m,r)

Je commencerais par chercher deux valeurs de départ r et r1, encadrant la racine.
La boucle for devient inutile si pour la boucle while, on prend comme condition de sortie abs(r1-r)<10^-n.
En stockant à chaque tour dans r1 la valeur de r qui va être modifiée...

J'ai aussi écrit le prog pour travailler avec une liste r...

@+

[EDIT] avec [tex]m\geqslant 0[/tex] :
[tex]P_m(x)=x^3+mx^2+1[/tex]
[tex]P'_m(x)=3x^2+2mx=x(3x+2m)[/tex]
Pour te donner à réfléchir :

x       |-oo   -2m/3        0        +oo
--------|--------|----------|-----------|
P'm(x)  |   +    0     -    0     +     |
--------|--------|----------|-----------|
        |  (4m^3+27)/27            +oo  |
        |      /     \            /     |
Pm(x)   |     /       \          /      |
        |    /         \        /       |
        |   /           \   1  /        |
         -oo                      

|

Dernière modification par yoshi (04-06-2016 18:02:37)

---

Arx Tarpeia Capitoli proxima...

Blis3

Invité

Re : Polynome

ok merci je vais y réfléchir

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : Polynome

Salut,

Où en es-tu ?

@+

---

Arx Tarpeia Capitoli proxima...

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : Polynome

Re,

Je n'ai fait qu'une seule fonction puisque l'énoncé n'en demande qu'une :

Ecrire une fonction informatique qui recevant m et un entier n

Avec Python 3.4

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
def approchee(m,n):
    x=int(-2*m/3)
    x1=x
    sol=[x]
    while x**3+m*x**2+1>=0:
        x-=1
    while abs(x1-x)>10**(-n):
        poly=x**3+m*x**2+1
        deriv=3*x**2+2*m*x
        x1=x
        x-=poly/deriv
        sol.append(x)
    frm="%3."+str(n)+"f"
    print("Valeur approchée de r("+str(n)+") : "+frm % x)
    return
 

Tu lances ce programme, puis dans la fenêtre (console) de résultats, tu tapes ce que tu veux, par exemple :

Python 3.4.0 (v3.4.0:04f714765c13, Mar 16 2014, 19:24:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>>
>>> approchee(1,12)
Valeur approchée de r(12) : -1.465571231877
>>> approchee(2,6)
Valeur approchée de r(6) : -2.205569
>>> approchee(5,8)
Valeur approchée de r(8) : -5.03937733
>>>

La fonction approchee(m,n) une fois en mémoire (après lancement), le petit script te rend la main, et tu vois apparaître >>>
Là, tu tapes approchee(m,n) où tu remplaces m et n par des nombres qui conviennent...
D'après le tableau de variation (m étant positif ou nul, je le rappelle), je sais que j'ai un extremum pour [tex]x =-\frac{2m}{3}[/tex], [tex]x[/tex] est négatif.
L'ordonnée de cet extremum valant [tex]\frac{4m^3+27}{27}[/tex], je sais donc qu'elle est positive.
Je donne donc à x la valeur de la partie entière de -2m/3 et je garde cette valeur de x dans la variable x1 et je la stocke dans la liste sol.
Puis, la fonction étant strictement croissante sur [tex]\left ]-\infty\;;\;-\frac{2m}{3}\right][/tex], j'applique le théorème des gendarmes pour encadrer la valeur de la racine cherchée entre deux valeurs entières, d'où la 1ere boucle while : tant que la valeur du polynôme n'est pas strictement négative je recalcule en décrémentant x de 1...
Puis deuxième boucle, je teste si la valeur absolue de [tex]x_1-x[/tex] est inférieure ou égale à 10^-n et j'ajoute [tex]x[/tex] à la liste sol
Lorsque c'est le cas, on sort de la boucle...
Pour une précision de 10^-6, il m'a paru inutile d'afficher plus de 6 chiffres après la virgule, donc je formatte l'affichage :
je demande 3 chiffres avant la virgule et n après et j'ajoute f comme float (nombre à virgule).
Pour n = 6, je demanderais print ("%3.6f" % x)
Pour n = 8, je demanderais print ("%3.8f" % x)
Pour n = 12 ,je demanderais print ("%3.12f" % x)
Et je me suis demandé comment le faire automatiquement...
"%3.6f", "%3.8f", "%3.12f" étant des chaînes de caractères (string), j'ai fabriqué la chaîne frm en concaténant :
"%3."     str(n)       et "f"
En simplifiant comme ci-dessus le print() deviendrait :
print (frm % x)

J'ai amélioré l'affichage en pensant que r était mis pour racine et t (tu ne m'as pas dit ce que représentait ce t) mis pour n
Donc, j'ai pris sur moi de traduire r(10) par racine à 10^-10 près...
r ne pouvant être une liste puisque le travail demandé devant être fait en Python, en Python, l'élément d'indice t d'une liste r s'écrit r[t] et non r(t)...

A te lire... peut-être !

---

Arx Tarpeia Capitoli proxima...