Discussion :

[Avi.Py]

Bonjour ! J'aurai besoin de votre aide sur quelques programmes . L'entièreté de mon TP porte sur les fonctions polynomiales et me demande de créer des fonctions visant à "exploiter" des données de ces fonctions comme par exemple créer une fonction qui permet de déterminer le degré d'une équation etc.

J'ai donc déjà créer une fonction python : poly_simple permettant de supprimer tous les coefficients nuls situés avant le premier coefficient non nul. En d'autres termes, la fonction supprime les coefficients nuls inutiles.

Examples
--------
>>> poly_simple([0, 1])
[1]
>>> poly_simple([0, 0])
[]
>>> poly_simple([1, 0, 1, 0])
[1, 0, 1, 0]
"""

Voice le code de cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
def poly_simple(poly):
 
    i = 0
    while i < len(poly) and poly[i] == 0:
        i += 1
    return poly[i:]

J'aurai donc besoin de votre aide pour élaborer tout d'abord un code permettant de retourner le degré d'une fonction polynomiale.

Par exemple:


Le polynôme de degré 2, P(X) = 2*X^2 - 1 est représenté par la liste [2, 0, -1] de longueur 3.

>>> poly_degre([3, 1])
1
>>> poly_degre([1, 2, 3, 2, 0, -1])
5
>>> poly_degre([0, 1])
0
>>> poly_degre([0, 1, 0])
1
>>> poly_degre([1])
0
>>> poly_degre([])
-1

Merci de votre aide !

[BufferBob]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

[Avi.Py]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

Merci beaucoup de ton aide cela fonctionne !

Je vais essayer de continuer le TP je vous enverrai mon code pour vérification.

Merci pour votre réponse.

[Avi.Py]

salut,

ce que tu pourrais faire c'est virer de la liste tous les zéros qui sont à gauche tant qu'/si il y en a, après quoi vu que tu vires déjà les zéros à gauche dans la liste, le degré de ton polynôme c'est juste len(poly)-1 finalement

J'ai donc continué le Tp de mon côté pour obtenir plusieurs fonctions.

La fonction permettant de renvoyer le degré de la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# %%
import doctest
from math import sqrt, isclose
def poly_simple(poly):
    i = 0
    while i < len(poly) and poly[i] == 0:
        i += 1
    return poly[i:]
 
## EX 1
 
def poly_degre(poly):
    a=poly_simple(poly)
    degré=len(a)-1
    return degré
 
 
 
if  poly_degre([3, 1])!=1:
    print ('La fonction poly_degre([3, 1])!=1 ne renvoie pas le bon degré')
 
if  poly_degre([1, 2, 3, 2, 0, -1])!=5:
    print ('La fonction poly_degre([1, 2, 3, 2, 0, -1])!=5 ne renvoie pas le bon degré')
 
if  poly_degre([0, 1])!=0:
    print ('La fonction poly_degre([0, 1])!=0 ne renvoie pas le bon degré')
 
if  poly_degre([0, 1, 0])!=1:
    print ('La fonction poly_degre([0, 1, 0])!=1 ne renvoie pas le bon degré')
 
if  poly_degre([1])!=0:
    print ('La fonction poly_degre([1])!=0 ne renvoie pas le bon degré')
 
if  poly_degre([])!=-1:
    print ('La fonction poly_degre([])!=-1 ne renvoie pas le bon degré')

La fonction permettant d'évaluer le polynome au point x0 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def poly_eval(poly,x0):
 
    res=0
    poly_puissance=len(poly)-1
 
    for Mv in range (len(poly)):
 
        res+= poly[Mv]*x0**(poly_puissance-Mv)
 
    return res
 
 
if not isclose( poly_eval([2, 0, -1], sqrt(2)), 3.0 ):
    print ('L appel de la fonction isclose( poly_eval([2, 0, -1], sqrt(2)), 3.0 ) est fausse')
 
if not isclose( poly_eval([2, 0, -1], -sqrt(2)), 3.0):
    print ('L appel de la fonction isclose( poly_eval([2, 0, -1], -sqrt(2)), 3.0 ) est fausse')
 
if not isclose( poly_eval([2, 0, -1], -1.0), 1.0):
    print ('L appel de la fonction isclose( poly_eval(poly_eval([2, 0, -1], -1.0), 1.0 ) est fausse')
 
if not isclose(poly_eval([2, 0, -1], -1.0), 1.0):
    print ('L appel de la fonction isclose(poly_eval([2, 0, -1], -1.0), 1.0) est fausse')

Et enfin une fonction permettant de résoudre une équation du 2nd degré :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def poly_quadratique(poly):
 
    solutions=[]
 
    if poly_degre(poly)!=2:
        return 'None'
 
    A=poly[0]
    B=poly[1]
    C=poly[2]
 
 
 
    delta=B*B-4*A*C # On calcule delta, le discriminant, en fonction de A,B et C
 
 
    if delta <0:
        return (solutions) # Lorsque delta est négatif, il n'y a pas de solutions
    if delta==0:
        x=-B/2*A # Calcul de X
        solutions+=[x]
        return (solutions)
    if delta >0:
        racine_carre_delta=sqrt(delta) # On calcul la racine carré de delta
        k=-B-racine_carre_delta # Variable qui va intervenir dans le calcul de X1
        l=-B+racine_carre_delta # Variable qui va intervenir dans le calcul de x2
        m=2*A # Variable qui va intervenir dans le calcul de X1 et X2
        x1=k/m # Calcul de X1
        x2=l/m # Calcul de X2
        solutions+=[x1,x2]
        return (solutions)
 
if not isclose(  poly_quadratique([1, 0, -2])[0], -sqrt(2)  ):
    print ('L appel de la fonction isclose(  poly_quadratique([1, 0, -2])[0], -sqrt(2)  ) est fausse')
 
if not isclose(  poly_quadratique([1, 0, -2])[1], sqrt(2)  ):
    print ('L appel de la fonction isclose(  poly_quadratique([1, 0, -2])[1], sqrt(2)  ) est fausse')
 
if  poly_quadratique([1, 0, 1])!=[]:
    print ('La fonction poly_quadratique([1, 0, 1])!=[] n a pas de solutions')
 
if  poly_quadratique([1, 0, 0])!=[0.0]:
    print ('La fonction poly_quadratique([1, 0, 0])!=[0.0] ne renvoie pas les bonnes racines')
 
if  poly_quadratique([1, 0])!='None':
    print ('La fonction poly_quadratique([1, 0])!=[None] n est pas une fonction du 2nd degré')
 
if  poly_quadratique([1,0,0,0])!='None':
    print ('La fonction poly_quadratique([1,0,0,0])!=None n est pas une fonction du 2nd degré')

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Tout d'abord, il faudrait que j'obtienne une fonction poly_complete(poly,n) qui complète une représentation avec des 0 jusqu'à n.

Exemples :

• poly_complete([2, 0, -1], 1) → [2, 0, -1]
• poly_complete([2, 0, -1], 2) → [2, 0, -1]
• poly_complete([2, 0, -1], 3) → [0, 2, 0, -1]
• poly_complete([1], 0) → [1]
• poly_complete([1], 1) → [0, 1]
• poly_complete([], 0) → [0]
• poly_complete([], 1) → [0, 0]
• poly_complete([], 2) → [0, 0, 0]

[Sve@r]

Bonjour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def poly_degre(poly):
    a=poly_simple(poly)
    degré=len(a)-1
    return degré

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def poly_degre(poly):
	return len(poly_simple(poly))-1

Et enfin une fonction permettant de résoudre une équation du 2nd degré :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def poly_quadratique(poly):
 
    solutions=[]
 
    if poly_degre(poly)!=2:
        return 'None'
 
    A=poly[0]
    B=poly[1]
    C=poly[2]
 
 
 
    delta=B*B-4*A*C # On calcule delta, le discriminant, en fonction de A,B et C
 
 
    if delta <0:
        return (solutions) # Lorsque delta est négatif, il n'y a pas de solutions
    if delta==0:
        x=-B/2*A # Calcul de X
        solutions+=[x]
        return (solutions)
    if delta >0:
        racine_carre_delta=sqrt(delta) # On calcul la racine carré de delta
        k=-B-racine_carre_delta # Variable qui va intervenir dans le calcul de X1
        l=-B+racine_carre_delta # Variable qui va intervenir dans le calcul de x2
        m=2*A # Variable qui va intervenir dans le calcul de X1 et X2
        x1=k/m # Calcul de X1
        x2=l/m # Calcul de X2
        solutions+=[x1,x2]
        return (solutions)

T'es sûr pour la string None retournée au début? Il y a tant d'objets Python permettant de retourner un état (True, False, None) que retourner une string pour indiquer ledit état est assez mal vu. Une string implique une notion de langage qui dépend aussi du lecteur. Et au retour, comparer deux strings est plus long que comparer deux états. En plus retourner une string "None" est tellement tompeur par rapport à l'état None...
Ensuite pas de parenthèses au return. Et enfin au lieu de créer le tableau "solutions" à partir des solutions puis retourner le tableau, autant retourner directement les solutions...

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
	if delta <0: return [] # Lorsque delta est négatif, il n'y a pas de solutions
 
	A*=2 # Ben oui, le A initial ne sert plus à rien...
	B=-B/A
	if delta==0: return [B,]
 
	# Evident que ici delta >0 !!!
	r=sqrt(delta)/A
	return [B-r, B+r]

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Tout d'abord, il faudrait que j'obtienne une fonction poly_complete(poly,n) qui complète une représentation avec des 0 jusqu'à n.

Exemples :

• poly_complete([2, 0, -1], 1) → [2, 0, -1]
• poly_complete([2, 0, -1], 2) → [2, 0, -1]
• poly_complete([2, 0, -1], 3) → [0, 2, 0, -1]
• poly_complete([1], 0) → [1]
• poly_complete([1], 1) → [0, 1]
• poly_complete([], 0) → [0]
• poly_complete([], 1) → [0, 0]
• poly_complete([], 2) → [0, 0, 0]

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def poly_complete(poly, n):
	if len(poly) > n: return poly
	return [0,] * (n - len(poly) + 1) + poly

[Avi.Py]

Bonjour

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def poly_degre(poly):
	return len(poly_simple(poly))-1

T'es sûr pour la string None retournée au début? Il y a tant d'objets Python permettant de retourner un état (True, False, None) que retourner une string pour indiquer ledit état est assez mal vu. Une string implique une notion de langage qui dépend aussi du lecteur. Et au retour, comparer deux strings est plus long que comparer deux états. En plus retourner une string "None" est tellement tompeur par rapport à l'état None...
Ensuite pas de parenthèses au return. Et enfin au lieu de créer le tableau "solutions" à partir des solutions puis retourner le tableau, autant retourner directement les solutions...

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
	if delta <0: return [] # Lorsque delta est négatif, il n'y a pas de solutions
 
	A*=2 # Ben oui, le A initial ne sert plus à rien...
	B=-B/A
	if delta==0: return [B,]
 
	# Evident que ici delta >0 !!!
	r=sqrt(delta)/A
	return [B-r, B+r]

Merci pour toute ton aide!
Pour ce qui est du 'None' je suis contraint d'utiliser un str puisque j'ai comme consigne de renvoyer l'information "None" a l'utilisateur. Si j'utilise directement le caractère None tel quel le résultat de l'appel de la fonction renverra "rien" à l'utilisateur pour l'informer que la fonction saisie n'est pas une fonction du 2nd degré.

J'aurai donc besoin d'aide pour l'élaboration de plusieurs fonctions.

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def poly_complete(poly, n):
	if len(poly) > n: return poly
	return [0,] * (n - len(poly) + 1) + poly

Pourrais tu m'expliquer cette ligne en particulier je n'arrive pas a bien l'interpréter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return [0,] * (n - len(poly) + 1) + poly

J'aurai donc besoins de plusieurs autres fonctions me permettant d'effectuer plusieurs types d'opérations ( additionner, dériver, multiplier ):

L'addition tel que poly_addition(poly_1, poly_2)

• poly_addition([], [2, 0, 1]) → [2, 0, 1]
• poly_addition([2, 0, 1], []) → [2, 0, 1]
• poly_addition([3, 1, 1], [3, 0, 2, 2]) → [3, 3, 3, 3]
• poly_addition([2, 0, 1], [-2, 0, 1]) → [2]

La dérivation tel que poly_derive(poly)

• poly_derive([2, 0, 1])→ [4, 0]
• poly_derive([3, 0, 2, 2]) → [9, 0, 2]

et la multiplication poly_produit(poly_1, poly_2)

• poly_produit([5, 3, 2], [1]) → [5, 3, 2]
• poly_produit([5, 3, 2], []) → []
• poly_produit([5, 3, 2], [11, 7]) → [55, 68, 43, 14]
• poly_produit([11, 7], [5, 3, 2]) → [55, 68, 43, 14]
• poly_produit([1, 1], [1, 1]) → [1, 2, 1]

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairez la dessus cela m'aiderait grandement merci encore !

[wiztricks]

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairez la dessus cela m'aiderait grandement merci encore !

Profitez en pour revoir votre cours sur les listes ou ouvrir un tuto... et essayez de faire quelque chose avec ce que vous avez compris plutôt que d'attendre qu'on écrive le code pour vous.

- W

[Sve@r]

Pour ce qui est du 'None' je suis contraint d'utiliser un str puisque j'ai comme consigne de renvoyer l'information "None" a l'utilisateur.

Je pense que le créateur parle bel et bien de l'état "None" qu'il nomme ici "information".

Si j'utilise directement le caractère None tel quel le résultat de l'appel de la fonction renverra "rien" à l'utilisateur pour l'informer que la fonction saisie n'est pas une fonction du 2nd degré.

Ne confond pas "rien" et "None". None c'est "quelque chose de concret signifiant rien" mais ça reste quelque chose. De plus, toute fonction Python renvoie toujours quelque chose et si le programmeur ne met pas de return explicite alors elle retourne None

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> def fct(): pass
...
>>> a=fct()
>>> print(a)
None
>>> print(a is None)
True
>>> print("la fonction a marché" if a is None else "")
la fonction a marché

Pourrais tu m'expliquer cette ligne en particulier je n'arrive pas a bien l'interpréter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return [0,] * (n - len(poly) + 1) + poly

Un code d'exemple n'est pas fait pour rester passif devant en attendant qu'une lumière s'allume au plafond. Tu as aussi le droit de t'en inspirer pour faire tes propres tests...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> ["toto",]*10
['toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto', 'toto']
>>> >>> ["toto",]*5 + ["titi",]*2
['toto', 'toto', 'toto', 'toto', 'toto', 'titi', 'titi']

Je n'arrive pas a manipuler correctement les listes pour effectuer toutes ces opérations, si vous pouvez m'éclairer la dessus cela m'aiderait grandement merci encore !

Ben l'addition donnera un nouveau polynome contenant l'addition de chaque coefficient de son rang (0 pour un rang non écrit). Exemple [3, 1, 1] + [3, 0, 2, 2] = [0, 3, 1, 1] + [3, 0, 2, 2] = [0+3, 3+0, 1+2, 1+2]
Pour la dérivée c'est pas non plus super compliqué. La dérivée de x^n c'est nx^(n-1). Et (kf)' ("k" coefficient multiplicateur, "f" fonction à dériver) = k(f'). Ainsi la dérivée de x^3 c'est 3x² donc la dérivée de 4x^3 c'est 4*3x² soit 12x². Donc la dérivée de [3, 0, 2, 2] (sous-entendu 3x^3 + 0x² + 2x + 2 c'est 3*(3x²) + 0x + 2 soit [9, 0, 2]. Bref juste un décalage dans la liste

Et pour la multiplication de polynomes, suffit d'appliquer (5x² + 3x + 2) * (11x + 7) => (5x² * 11x) + (5x²*7+3x*11x) + (3x*7 + 11x*2) + (7*2) = 55x^3 + (33+35)x² + (21+22)x + 14 = 55x^3 + 68x² + 43x + 14. Là à mon avis le moins compliqué sera de toujours positionner le polynöme de degré le plus haut soit toujours à gauche soit toujours à droite de l'autre.