%pylab inline
Partie 2¶
Définissez la fonction delta(n) (δ(n)) qui retourne 1 pour n=0, et 0 sinon.
def delta(n):
# ici on utilise le fait qu'un booléen peut être converti en entier (True -> 1, False -> 0)
# ce qui permettra d'accepter directement une comparaison avec un np.array
return n == 0
Afficher cette fonction sur l'intervalle [−20;20]×[−0.1;1.1] en utilisant la fonction stem.
X = np.arange(-20, 21) # on définit les abscisses des points
stem(X, delta(X))
# on définit les plages de valeurs d'affichage du graphique
ylim(-0.1, 1.1)
xlim(-20, 20)
Définir la fonction unit(n) qui retourne 0 pour n<0 et 1 sinon.
def unit(n):
# idem pour cette fonction, on utilise le type booléen
return n > 0
Afficher cette fonction sur l'intervalle [−20;20]×[−0.1;1.1] en utilisant la fonction stem.
stem(X, unit(X))
ylim(-0.1, 1.1)
xlim(-20, 20)
Tester et afficher sur [−20;20] les fonctions δ(n), δ(−n), δ(n−5) et δ(n+5) en 4 sous-figures avec en titre la fonction.
figure(figsize=(6,14)) # on définit la taille globale de la figure (en cm)
subplot(4, 1, 1) # on définit le partitionnement et la position de la sous-figure
stem(X, delta(X))
ylim(-0.1, 1.1)
xlim(-20, 20)
title("$\\delta(n)$")
subplot(4, 1, 2)
stem(X, delta(-X))
ylim(-0.1, 1.1)
xlim(-20, 20)
title("$\\delta(-n)$")
subplot(4, 1, 3)
stem(X, delta(X - 5))
ylim(-0.1, 1.1)
xlim(-20, 20)
title("$\\delta(n-5)$")
subplot(4, 1, 4)
stem(X, delta(X + 5))
ylim(-0.1, 1.1)
xlim(-20, 20)
title("$\\delta(n+5)$");
Afficher sur [−20;20] les fonctions $α^n×unit(n)$ pour les valeurs de α 0.95, 0.9, 0.6.
figure()
ylim(-0.1, 1.1)
xlim(-20, 20)
stem(X, (0.95**X) * unit(X), 'b')
stem(X, (0.9**X) * unit(X), 'r')
stem(X, (0.6**X) * unit(X), 'g')
Partie 3¶
Définissez le tableau Numpy array C, des valeurs de la fonction $cos(2πx)$ sur 100 points répartis uniformément entre -1 et 1.
X = linspace(-1, 1, 100)
C = np.cos(2*pi*X) # la fonction cos de numpy permet de simplifier l'écriture et vectoriser le calcul
Affichez sur [−1;1] la fonction $cos(2πx)$ avec 10 puis 100 points de résolution, en utilisant C.
figure()
xlim(-1.1, 1.1)
ylim(-1.1, 1.1)
stem(X[::10], C[::10]) # un array peut se parcourir comme une liste, ici on indique un pas de 10
figure()
xlim(-1.1, 1.1)
ylim(-1.1, 1.1)
stem(X, C)
Affichez sur [−1;1] la fonction $0.5×cos(2πx+1)$ avec 10 puis 100 points de résolution.
D = 0.5*np.cos(2*pi*X + 1)
figure()
xlim(-1.1, 1.1)
ylim(-1.1, 1.1)
stem(X[::10], D[::10])
figure()
xlim(-1.1, 1.1)
ylim(-1.1, 1.1)
stem(X, D)
Définissez la matrice M de dimension 4x3, remplie uniquement de la valeur 2.
M = full((4, 3), 2)
M
Extrayez la ligne 3, puis la colonne 3.
L3 = M[2, :] # l'indice de la 3e ligne est 2 (commence à 0)
print(L3)
C3 = M[:, 2]
print(C3)
Modifiez M de telle sorte que la ligne 2 soit égale à la ligne 2 plus 3 fois la ligne 4. Puis la colonne 1 égale à la colonne 1 plus la moitié de la colonne 3.
# d'abord la modification sur la ligne
M[1, :] = M[1, :] + 3*M[3, :]
M
# puis sur la colonne
M[:, 0] = M[:, 0] + 0.5*M[:, 2]
M
Changez les caractéristiques de M pour qu'elle soit maintenant une matrice 6x2.
# les nouvelles dimensions sont compatibles (12 éléments)
M = M.reshape((6,2))
M
Créez les matrices carré B et C 4x4 et de valeur respective 2 et 3. Les résultats de B+C, B*C et B@C correspondent-ils bien avec ce que vous pensiez ?
B = full((4,4), 2)
C = full((4,4), 3)
B, C
B + C # addition élément par élément, normal
B * C # attention, ici produit élément par élément
B @ C # vrai produit matriciel
Créez une matrice 3x3 avec les valeurs de 0 à 8.
N = arange(9).reshape((3, 3))
N
Trouvez les indices des valeurs supérieures à 3 dans le tableau [1, 0, 2, 0, 0, 3, 4, 0, 5].
where(array([1, 0, 2, 0, 0, 3, 4, 0, 5]) > 3)
# donne les indices des positions sur une dimension, comme le vecteur en entrée
Trouvez les indices des valeurs de M supérieures à 3.
where(M > 3)
# donne les indices mais sur deux dimensions: une liste des lignes, une liste des colonnes
Modifiez la matrice M afin de mettre à -1 toutes les valeurs supérieures à 3.
print(M)
M[M > 3] = -1
M
Partie 4¶
Définissez la fonction w_k qui aux paramètres k et N retourne le k-ième vecteur $w_k=[e^{2iπkn/N}]_{n∈[0,N[}$ de la base $\mathbb{C}^N$. La valeur par défaut de $N$ sera de 64.
def w_k(k, N=64):
return exp(2*1j*pi*k*arange(0,N)/(N*1.0))
Définissez la fonction affiche_w_k, qui pour un k donné affiche dans une sous-figure les parties réelles du vecteur $w_k$ et dans une autre sous-figure les parties imaginaires du vecteur $w_k$. Les signaux étant discrets, utilisez la fonction stem à la place de la fonction plot.
def afficher_w_k(k):
figure(figsize=(12,6))
subplot(121)
stem(arange(0, 64), real(w_k(k)))
ylim(-1.1, 1.1)
title("partie réelle de w_" + str(k))
subplot(122)
stem(arange(0, 64), imag(w_k(k)))
title("partie imaginaire de w_" + str(k))
ylim(-1.1, 1.1)
afficher_w_k(0)
Afficher en utilisant la fonction précédente les vecteurs $w_k$ et $w_{N−k}$ sur la base $\mathbb{C}^{64}$ pour les valeurs suivantes de $k$ : 0, 1, 2, 3, 4, 16, 20, 30, 31 et 32. Utilisez la fonction map pour faire ces affichages d'un coup. (Remarque: map retourne un générateur, il faut donc parcourir ce générateur pour exécuter les affichages. Pour cela, convertissez le simplement en liste : list(map(...))).
list(map(afficher_w_k, array([[k, 64-k] for k in [0, 1, 2, 3, 4, 16, 20, 30, 31, 32]]).flatten()));
Partie 5¶
Définissez la fonction scalaire(x, k) qui retourne pour un k fixé le produit scalaire entre un vecteur $x=x[n]$ et le vecteur $w_k$. Le résultat attendu est un nombre, réel ou complexe, mais pas un vecteur.
def scalaire(x, k):
return vdot(x, w_k(k))
Définissez la fonction decompose(x) qui retourne un vecteur formé des produits scalaires du signal $x=x[n]$ sur toute la base des $w_k$. Le premier élément sera $<x|w_0>$, le deuxième sera $<x|w_1>$ etc.
def decompose(x):
return array([scalaire(x, k) for k in range(64)])
decompose(w_k(1))
Définissez la fonction affiche_decompose(x) qui affiche dans quatre sous-figures le module, la phase, la partie réelle et la partie imaginaire du vecteur égale à la décomposition du vecteur $x$. Affichez la décomposition pour le vecteur $cos(\frac{2\pi}{4}n)$ sur cette base $\mathbb{C}^{64}$.
def affiche_decompose(Z):
figure(figsize=(8, 8))
subplot(2, 2, 1)
stem(abs(Z))
title("module")
subplot(2, 2, 2)
# stem(angle(Z))
Z[abs(Z) < 10**(-10)] = 0
stem(angle(Z))
title("phase")
ylim(-pi, pi)
subplot(2, 2, 3)
stem(real(Z))
title("partie réelle")
subplot(2, 2, 4)
stem(imag(Z))
title("partie imaginaire")
X = cos(2*pi/4*arange(64))
Y = decompose(X)
affiche_decompose(Y)
Écrivez le code permettant de d'indiquer quels sont les indices et les valeurs à ces indices pour lesquels les contributions en module sont non-nulles ?
# attention aux comparaisons à 0 quand on manipule des floats
where(abs(Y) > 10**(-10))
Quels sont ces indices et valeurs pour le vecteur défini par $cos(\frac{2π}{4}n+π/4)$.
X2 = cos(2*pi/4*arange(64) + pi/4)
Y2 = decompose(X2)
affiche_decompose(Y2)
where(abs(Y2) > 10**(-10))
Et pour le vecteur $cos(\frac{2π}{15}n)$. Que constatez-vous ?
X3 = cos(2*pi/15*arange(64))
Y3 = decompose(X3)
affiche_decompose(Y3)
