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)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
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.
Le 15-03-2022, Lulu <lulu042@fry.fr.invalid> 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 ?
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.
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.
Lulu <lulu042@fry.fr.invalid> writes:
Le 15-03-2022, Lulu <lulu042@fry.fr.invalid> 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().
[...] 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.
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.
Le 15-03-2022, Alain Ketterlin <alain@universite-de-strasbourg.fr.invalid> a écrit :
Lulu <lulu042@fry.fr.invalid> writes:
Le 15-03-2022, Lulu <lulu042@fry.fr.invalid> 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 !!
[...] 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().