Discussion :

[Joshua_]

Bonjour,

Voilà mon problème, je cherche à créer un signal sinusoidale dont l'amplitude décroit avec le temps jusqu'à devenir nulle et récupérer les coordonnées des points.
Bon c'est pas clair alors voilà un petit schéma :

http://www.hostingpics.net/viewer.php?id=40984374i.png

Les entrées de mon programme seraient les suivantes :

• Valeur de y minimun.
• Valeur de y maximun.
• Valeur de y final. (qui peux être différent de y moyenne ! )
• Nombre de période.
• Nombre de point par période.

Orange : (Y max + Y min)/2 (c'est simplement pour montrer qu'il est différent du Y final)

Les sorties de mon programmes seraient les suivantes :

• Liste des ordonnées des points.

J'ai vraiment aucune idée de comment je pourrais coder un tel programme, j'ai jamais utilisé python pour faire des maths ^^"
Quelqu'un pour m'aider ?
Merci d'avance.

(ps : si certains pensent que c'est pour un devoir, ils se trompent c'est pour générer automatiquement un fichier xml pour un logiciel de création de musique )

[__dardanos__]

Bonsoir Joshua,

Tu as fait le plus dur. Le signal est de la forme : f(t) = c * sin(t) * exp(-a*t) + b

Je trouve plus naturel de définir comme variables d'entrée :

• la valeur moyenne du signal (qui s'identifie à b),
• son amplitude (qui s'identifie à c),
• et le rapport d'atténuation att défini comme le rapport des enveloppes pour t=0 et pour la dernière période.

On a alors : att = exp(a*nb_per*2*pi), avec nb_per : le nombre de périodes de la simulation.
Ayant a, il n'y a pas vraiment de difficulté. Les tableaux numpy sont bien pratiques pour faire ça.

[Julien N]

c * sin(t) * exp(-a*t) + b

Dans ce cas le signal tend vers la valeur moyenne b, or (corrigez moi si j'ai mal compris) ll semblerait qu'on cherche ici à faire tendre le signal vers une valeur y final (en vert sur le schéma) différent de y max - y min.

Sur un signal fortement atténué, y max - y min est il est vrai déjà différent de b...

Ju

[Joshua_]

Bonjour __dardanos__ && Julien N ,
Avant tout, merci de vos réponses
Mais malheureusement comme l'as souligné Julien N, la formule :

f(t) = c * sin(t) * exp(-a*t) + b

Ne correspond pas à ma demande, car je veux que le signal tend vers la ligne verte, et non l'orange

[Gakusei]

Bonjour Joshua_,

Je n'ai pas bien compris ce que représente l'asymptote orange? Si c'est le milieu entre la rouge et la bleu se serait (Ymax+Ymin)/2.

Bonjour __dardanos__ && Julien N ,
Avant tout, merci de vos réponses
Mais malheureusement comme l'as souligné Julien N, la formule :

Ne correspond pas à ma demande, car je veux que le signal tend vers la ligne verte, et non l'orange

Cette fonction tend vers b à l'infini donc c'est toi qui choisis la valeur que tu veux pour b (si tu connais l'équation d'asymptote de la verte tu remplace dans b).

[Julien N]

On peut modifier légèrement l'expression de _Dardanos_, en replaçant

b

par

b + 1/(d*t)

L'expression entière tend toujours vers b en l'infini, mais au voisinage de zéro, on décale soit vers le haut, soit vers le bas la courbe en fonction du choix de d.

Tu peux voir ce que cela fait avec l'exemple ci-dessous (coder avec mes pieds ):

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
# -*- coding:Utf-8 -*-
 
import numpy as np
from pylab import *	
 
 
def function(X,A,B,C,D):
    """ Fonction pour créer un signal """
 
    return [C*np.sin(2*np.pi*x)*np.exp(-A*x) + B + 1/(D*x) for x in X]
 
 
if __name__ == '__main__':
 
    # Constantes
    A = 0.5
    B = 2.0
    C = 3.0
    D = 2.0
 
    # Listes (attention, x ne peut être égal à 0.0)
    X = np.arange(1.0,20.0,0.1)
 
    # Appels de la fonction
    Y = function(X,A,B,C,D)
 
    # Vérification des résultats
    print 'Ymax-Ymin:\t', max(Y)-min(Y)
    print 'Yfinal:\t\t', Y[-1]
 
 
    # Plot
    plot(X,Y,'blue')
    show()

Ju

[__dardanos__]

On peut aussi introduire une asymétrie dans f(t) afin de décaler la valeur moyenne :

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
# -*- coding:Utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
 
def signal( maxi, mini, final, att, nb_per, nb_pts):
    t = np.linspace(0, 2*np.pi*nb_per, nb_per*nb_pts)
    a = np.log(att) / (2.0*np.pi*nb_per)
    y = np.sin(t) * np.exp(-a*t)
    y[y>0] *= np.abs(maxi - final)
    y[y<0] *= np.abs(final - mini)
    return t, y + final
 
if __name__ == '__main__':
    v_final = 20
    t, s = signal( maxi=100, mini=0, final=v_final, att=1000, nb_per=20, nb_pts=32)
    moy = np.ones_like(s) * np.mean(s)
    final = np.ones_like(s) * v_final
 
    plt.plot( t, s, t, moy, t, final)
    plt.show()

[Joshua_]

Julien N et __dardanos__,
Je vous remercie de vos réponses précises et fonctionnelles, je n'en demandais pas tant!

@Julien N
Cependant, j'ai du mal à comprendre le sens des variables, j'ai tenté de les modifier, mais je ne saisis pas vraiment ce qu'il se passe, pourrez-tu m'éclairer davantage sur l'utilité de chacune ?

@__dardanos__
Résultat très intéressant pour le point de l'atténuation, bien que je préfère la façon de faire de Julien N.

Encore merci à vous deux!
Je ne met pas le sujet comme résolu, n'ayant pas réussi encore à réaliser ce que je souhaite, mais je pense avoir toutes les cartes en main pour le faire maintenant.
J'aurais peut-etre besoin d'aide pour soigner le signal (aténuation, concanation) par la suite.

/me est heureux, vive l'entraide \o/

EDIT :
@Julien N,
En codant et relisant mes cours, j'ai très vite compris la signification des variables en fait

[Julien N]

Joshua_, il n'y a pas de quoi.

Cependant je te conseille d'étudier la proposition de __Dardanos__ que je trouve meilleure. Si tu n'es pas habitué au langage Python, tu as peut-être un peu de mal à comprendre en détail ce qui est fait, mais sa solution est plus "exploitable" que la mienne car elle prend en paramètres des données simples (Y_max, Y_min, Y_final, attenuation, nb_pts, nb_periods). Tu n'es pas obligé de tâtonner pour trouver les différents coefficients de ma solution.

Je suis certain que __Dardanos__ se fera un plaisir de t'éclairer sur certains points si nécessaire.

Ciao, Ju