Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

erreur matplotlib

3 réponses
Avatar
Lulu
Bonjour,

Je veux tracer un graphe avec 5 courbes, mais la plus simple des courbes
plante avec :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Traceback (most recent call last):
File "analyse_spectrale_original.py", line 37, in <module>
plot(t , x0, linewidth = ze_line_width)
File "/usr/local/lib/python3.8/dist-packages/matplotlib/pyplot.py", line 2757, in plot
return gca().plot(
File "/usr/local/lib/python3.8/dist-packages/matplotlib/axes/_axes.py", line 1632, in plot
lines = [*self._get_lines(*args, dataÚta, **kwargs)]
File "/usr/local/lib/python3.8/dist-packages/matplotlib/axes/_base.py", line 312, in __call__
yield from self._plot_args(this, kwargs)
File "/usr/local/lib/python3.8/dist-packages/matplotlib/axes/_base.py", line 498, in _plot_args
raise ValueError(f"x and y must have same first dimension, but "
ValueError: x and y must have same first dimension, but have shapes (500,) and (1,)
8<-----------8<---------8<----------8<----------8<----------8<----------8<

La ligne 37 de mon script cherche Í  tracer une constante : pour les 500
valeurs de t, x0 = 0.4 (et mon script fonctionne si je commente cette
ligne) :
plot(t , x0, linewidth = ze_line_width)

avec :
x0 = u0(t)

et :
def u0(t) : return 0.4

Mon script complet :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
1 #!/usr/bin/python3
2 # -*- coding: utf-8 -*-
3
4 import numpy as np
5 import math
6 from matplotlib.pyplot import *
7
8
9 f1=1.0
10 ze_line_width = 3
11
12 def u0(t) : return 0.4
13 def u1(t) : return np.sin( 2 * np.pi * f1 * t)
14 def u2(t) : return 0.5 * np.sin( 2 * 2 * np.pi * f1 * t - np.pi/3)
15 def u3(t) : return 0.2 * np.sin( 3 * 2 * np.pi * f1 * t + np.pi/4)
16
17 # def u(t):
18 # return 0.4 + 1.0 * np.sin( 2 * np.pi * f1 * t)\
19 # + 0.5 * np.sin( 2 * 2 * np.pi * f1 * t - np.pi/3)\
20 # + 0.2 * np.sin( 3 * 2 * np.pi * f1 * t + np.pi/4)
21
22 def u(t) : return u0(t) + u1(t) + u2(t) + u3(t)
23
24 N = 500
25 Tmax = 2.0
26 Te = Tmax/N
27 t = np.arange(N)*Te
28
29 x0 = u0(t)
30 x1 = u1(t)
31 x2 = u2(t)
32 x3 = u3(t)
33 x = u(t)
34
35 figure(figsize=(16,9))
36 plot(t , x, linewidth = ze_line_width)
37 plot(t , x0, linewidth = ze_line_width)
38 plot(t , x1, linewidth = ze_line_width)
39 plot(t , x2, linewidth = ze_line_width)
40 plot(t , x3, linewidth = ze_line_width)
41 xlabel('t')
42 ylabel('u')
43 axis([0,2,-2,2])
44 grid()
45 la_string = "signal temporel pour 3 harmoniques"
46 title(la_string, color='orange', fontsize = 20)
47
48 show()
49
50
51 figure(figsize=(16,9))
52 markers,stemlines,base = stem([0, 1, 2, 3], [0.8, 1.0, 0.5, 0.2], 'r')
53 setp(stemlines, 'linewidth', ze_line_width)
54
55 xlabel('f')
56 ylabel('A')
57 axis([-1,5,0,1])
58 grid()
59 la_string = "signal fréquenciel pour 3 harmoniques"
60 title(la_string, color='orange', fontsize = 20)
61
62 show()
8<-----------8<---------8<----------8<----------8<----------8<----------8<

Merci de votre aide.

3 réponses

Avatar
Lulu
Le 15-03-2022, Lulu a écrit :
Bonjour,
[...]
La ligne 37 de mon script cherche Í  tracer une constante : pour les 500
valeurs de t, x0 = 0.4 (et mon script fonctionne si je commente cette
ligne) :
plot(t , x0, linewidth = ze_line_width)
avec :
x0 = u0(t)
et :
def u0(t) : return 0.4
[...]

Je viens d'avoir l'idée de remplacer la fonction u0(t) par une fonction
qui dépend de t, mais avec une si faible variation que j'obtiens bien un
trait horizontal Í  0.4 :
def u0(t) : return 0.4 + np.sin( 0.01 * np.pi * f1 * t /100)
Et ça marche !
Mais je cherche Í  comprendre mon erreur : pourquoi n'est-il pas aussi
simple qu'attendu de tracer une fonction constante ?
Merci.
Avatar
Alain Ketterlin
Lulu writes:
Le 15-03-2022, Lulu a écrit :
Bonjour,

[...]
La ligne 37 de mon script cherche Í  tracer une constante : pour les 500
valeurs de t, x0 = 0.4 (et mon script fonctionne si je commente cette
ligne) :
plot(t , x0, linewidth = ze_line_width)
avec :
x0 = u0(t)
et :
def u0(t) : return 0.4
[...]

Je viens d'avoir l'idée de remplacer la fonction u0(t) par une fonction
qui dépend de t, mais avec une si faible variation que j'obtiens bien un
trait horizontal Í  0.4 :
def u0(t) : return 0.4 + np.sin( 0.01 * np.pi * f1 * t /100)
Et ça marche !
Mais je cherche Í  comprendre mon erreur : pourquoi n'est-il pas aussi
simple qu'attendu de tracer une fonction constante ?

L'explication est dans le message d'erreur de ton précédent message :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Traceback (most recent call last):
[...]
ValueError: x and y must have same first dimension, but have shapes (500,) and (1,)
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Ta fonction u0 (l'originale) ne crée pas un tableau, mais renvoie
simplement un flottant. Tes autres fonctions créent toutes des tableaux.
Par exemple :
13 def u1(t) : return np.sin( 2 * np.pi * f1 * t)

renvoie bien un tableau. Tu as l'impression de faire une bête
multiplication scalaire "2*..." mais en fait tu fais
(... un flottant ...) * t
et comme t est un tableau, cela crée un nouveau tableau, dont chaque
élément est la valeur de l'élement correspondant de t multiplé par
(...). Merci la surcharge des opérateurs.
Tes fonctions u0, u1 ... ne sont pas des fonctions qui calculent
la nouvelle valeur d'un élement de tableau, ce sont des fonctions qui
calculent de nouveaux tableaux.
Sauf ta fonction u0 originale, qui renvoie un flottant. Ta modification
"marche" pour la même raison : ta (nouvelle) fonction u0 crée maintenant
un tableau, parce qu'un des opérandes de ta formule est un tableau. Tu
obtiendrais le même résultat en créant directement un tableau rempli
avec la constante, avec numpy.full().
-- Alain.
Avatar
Lulu
Le 15-03-2022, Alain Ketterlin a écrit :
Lulu writes:
Le 15-03-2022, Lulu a écrit :
Bonjour,

[...]
La ligne 37 de mon script cherche Í  tracer une constante : pour les
500 valeurs de t, x0 = 0.4 (et mon script fonctionne si je commente
cette ligne) :
plot(t , x0, linewidth = ze_line_width)
avec :
x0 = u0(t)
et :
def u0(t) : return 0.4
[...]

Je viens d'avoir l'idée de remplacer la fonction u0(t) par une
fonction qui dépend de t, mais avec une si faible variation que
j'obtiens bien un trait horizontal Í  0.4 :
def u0(t) : return 0.4 + np.sin( 0.01 * np.pi * f1 * t /100)
Et ça marche !
Mais je cherche Í  comprendre mon erreur : pourquoi n'est-il pas aussi
simple qu'attendu de tracer une fonction constante ?

L'explication est dans le message d'erreur de ton précédent message :
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Traceback (most recent call last):
[...]
ValueError: x and y must have same first dimension, but have shapes (500,) and (1,)
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Ta fonction u0 (l'originale) ne crée pas un tableau, mais renvoie
simplement un flottant. Tes autres fonctions créent toutes des tableaux.
Par exemple :
13 def u1(t) : return np.sin( 2 * np.pi * f1 * t)

renvoie bien un tableau. Tu as l'impression de faire une bête
multiplication scalaire "2*..." mais en fait tu fais
(... un flottant ...) * t
et comme t est un tableau, cela crée un nouveau tableau, dont chaque
élément est la valeur de l'élement correspondant de t multiplé par
(...). Merci la surcharge des opérateurs.
Tes fonctions u0, u1 ... ne sont pas des fonctions qui calculent la
nouvelle valeur d'un élement de tableau, ce sont des fonctions qui
calculent de nouveaux tableaux.
Sauf ta fonction u0 originale, qui renvoie un flottant. Ta
modification "marche" pour la même raison : ta (nouvelle) fonction u0
crée maintenant un tableau, parce qu'un des opérandes de ta formule
est un tableau. Tu obtiendrais le même résultat en créant directement
un tableau rempli avec la constante, avec numpy.full().

Ça m'apprendra a récupérer des scripts Í  droite ou Í  gauche sans
analyser leur fonctionnement : je n'avais même pas conscience de
manipuler des tableaux !!
Merci encore pour ton aide et pour numpy.full().
-- Alain.