diff --git a/docs/SAR_audio_Rendu_final.pdf b/docs/SAR_audio_Rendu_final.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..255cff44b3ac2320dea5a37684da64f53f7f9742
Binary files /dev/null and b/docs/SAR_audio_Rendu_final.pdf differ
diff --git a/src/analyse_delay.m b/src/analyse_delay.m
new file mode 100644
index 0000000000000000000000000000000000000000..8f332b3ae862756a7c4043b5788625ebc29e7120
--- /dev/null
+++ b/src/analyse_delay.m
@@ -0,0 +1,28 @@
+% Paramètres de l'effet de delay
+fe    = 44100;              
+tau   = round(0.25 * fe);    
+g     = 0.8;                 
+
+% Vecteurs de coefficients du filtre IIR
+b = 1;
+a = [1, zeros(1, tau-1), g]; 
+
+% Impulsion unitaire pour mesurer la réponse impulsionnelle
+N   = 11 * tau;              
+x   = [1, zeros(1, N-1)];   
+
+% Calcul de la réponse impulsionnelle via filter ---
+h = filter(b, a, x);
+
+% Réduction et conversion en temps pour visualisation sur [0, 10τ]
+Lvis  = 10 * tau;
+h_vis = h(1:Lvis);
+t     = (0:Lvis-1) / fe;    
+
+% Affichage de la réponse impulsionnelle
+figure;
+stem(t, h_vis, 'filled');
+grid on;
+xlabel('Temps (s)');
+ylabel('h(n)');
+title('Réponse impulsionnelle du filtre de delay sur [0, 10\tau]');
\ No newline at end of file
diff --git a/src/effet_delay.m b/src/effet_delay.m
new file mode 100644
index 0000000000000000000000000000000000000000..6afe424ea6835e74a021916289e61f372ff6c309
--- /dev/null
+++ b/src/effet_delay.m
@@ -0,0 +1,9 @@
+function y = effet_delay(x, t_delay, g, fe)
+
+tau = round(t_delay * fe);
+
+b = 1;
+a = [1, zeros(1, tau-1), g];
+
+y = filter(b, a, x);
+end
\ No newline at end of file
diff --git a/src/effet_delay_filtre.m b/src/effet_delay_filtre.m
new file mode 100644
index 0000000000000000000000000000000000000000..5de9dcdca31f10bc99efec41738ce901c405eb67
--- /dev/null
+++ b/src/effet_delay_filtre.m
@@ -0,0 +1,10 @@
+function y = effet_delay_filtre(x, t_delay, g, K, fe)
+
+tau = round(t_delay * fe);
+
+b = 1;                     
+
+a = [1, zeros(1, tau-1), ...   
+     repmat(g/K, 1, K)];       
+y = filter(b, a, x);
+end
diff --git a/src/effet_reverb.m b/src/effet_reverb.m
new file mode 100644
index 0000000000000000000000000000000000000000..68d5a0fd9b80e560e0b5d389fe8dfce846337d37
--- /dev/null
+++ b/src/effet_reverb.m
@@ -0,0 +1,4 @@
+function y = effet_reverb(x, h_est)
+
+y = conv(x, h_est);
+end
\ No newline at end of file
diff --git a/src/effet_reverb_FFT.m b/src/effet_reverb_FFT.m
new file mode 100644
index 0000000000000000000000000000000000000000..59345ba4b3fbab1cedfcf08f76e18910293697db
--- /dev/null
+++ b/src/effet_reverb_FFT.m
@@ -0,0 +1,12 @@
+function [y_fft, elapsed] = effet_reverb_FFT(x, h_est)
+NFFT = max(length(x), length(h_est));
+
+tic;
+
+X = fft(x, NFFT);
+H = fft(h_est, NFFT);
+
+Y = X .* H;
+y_fft = ifft(Y, NFFT);
+elapsed = toc;
+end
\ No newline at end of file
diff --git a/src/example_with_wave_file.m b/src/example_with_wave_file.m
deleted file mode 100644
index e288ffce5280fbee6268f915d49b999fd7d6082e..0000000000000000000000000000000000000000
--- a/src/example_with_wave_file.m
+++ /dev/null
@@ -1,12 +0,0 @@
-%% this is a simple example to read and play a wave file with matlab
-
-% set a string variable to a wave filename we want to open:
-toneFileName = "wav/single_tone_piano1.wav";
-% read the content of the wave file:
-[data,fe] = audioread(toneFileName);
-% data is a matrix with 2 columns if the sound is stereo; keep the mono to ease further processing
-data = data(:,1); 
-% get the number of sample in vector data
-N = length(data);
-% play the sound in the audio output:
-soundsc(data,fe);
\ No newline at end of file
diff --git a/src/figure 1_2.jpg b/src/figure 1_2.jpg
deleted file mode 100644
index 3db52e7efb7b0a12c7f3d3eead08a5048b721b01..0000000000000000000000000000000000000000
Binary files a/src/figure 1_2.jpg and /dev/null differ
diff --git a/src/figure 2_2.jpg b/src/figure 2_2.jpg
deleted file mode 100644
index 5b98bc9461446f6a390bea238e06e41ed6955555..0000000000000000000000000000000000000000
Binary files a/src/figure 2_2.jpg and /dev/null differ
diff --git a/src/figure 3_12.jpg b/src/figure 3_12.jpg
deleted file mode 100644
index f0a2e8b785b9b2615077d698b45f6088d4d3562e..0000000000000000000000000000000000000000
Binary files a/src/figure 3_12.jpg and /dev/null differ
diff --git a/src/figure 3_3.jpg b/src/figure 3_3.jpg
deleted file mode 100644
index 8640dbb316fc0b0a2f2aad9a0020b988bad99719..0000000000000000000000000000000000000000
Binary files a/src/figure 3_3.jpg and /dev/null differ
diff --git a/src/figure 3_4.jpg b/src/figure 3_4.jpg
deleted file mode 100644
index 481cb7d0a5686bd6c0303bb4d3d9c3fb68476b2f..0000000000000000000000000000000000000000
Binary files a/src/figure 3_4.jpg and /dev/null differ
diff --git a/src/figure_1_2.jpg b/src/figure_1_2.jpg
deleted file mode 100644
index 2cdc1653058d7ab0f06058755150b8cd0eec3c3c..0000000000000000000000000000000000000000
Binary files a/src/figure_1_2.jpg and /dev/null differ
diff --git a/src/guitare_reverb_norm.wav b/src/guitare_reverb_norm.wav
deleted file mode 100644
index 14998e8911a03ba5969ab0ee23584af18087edb0..0000000000000000000000000000000000000000
Binary files a/src/guitare_reverb_norm.wav and /dev/null differ
diff --git a/src/question22.m b/src/question22.m
deleted file mode 100644
index 9b9d793baf0ca2182936af79a37df8f66fe199e0..0000000000000000000000000000000000000000
--- a/src/question22.m
+++ /dev/null
@@ -1,27 +0,0 @@
-% Question 2.2: Spectre du filtre passe-bas d'ordre 1 via filter et FFT
-
-% 1. Paramètres
-Fs = 44100;              % Fréquence d'échantillonnage (Hz)
-b  = [1 1]/2;            % Coefficients numérateur
-a  = 1;                  % Coefficient dénominateur (FIR)
-N  = 1024;               % Nombre de points FFT et longueur impulsionnelle
-
-% 2. Réponse impulsionnelle via filter
-x_imp = [1, zeros(1, N-1)];   % Impulsion unitaire
-h     = filter(b, a, x_imp);  % Réponse impulsionnelle h[n]
-
-% 3. Spectre via FFT
-Hfft  = fft(h, N);
-f     = (0:N-1)/N * Fs;       % Axe des fréquences en Hz
-
-% 4. Tracé du spectre (limite à -100 dB)
-figure;
-plot(f, 20*log10(abs(Hfft)));
-hold on;
-plot(f, 20*log10(abs(cos(pi*f/Fs))), '--', 'LineWidth', 1.5);
-grid on;
-xlabel('Fréquence (Hz)');
-ylabel('Gain (dB)');
-legend('filtre simulé avec matlab', 'théorique |cos(pi* f/F_s)|');
-title('Spectre du filtre');
-ylim([-60, 0]);  % Ne pas afficher en dessous de -100 dB
\ No newline at end of file
diff --git a/src/question35.m b/src/question35.m
deleted file mode 100644
index ecf40a196ad444c6229a9ac8b7143af444199753..0000000000000000000000000000000000000000
--- a/src/question35.m
+++ /dev/null
@@ -1,15 +0,0 @@
-function y = effet_reverb(x, h_est)
-% EFFET_REVERB Applique un effet de réverbération par convolution
-%   y = effet_reverb(x, h_est) renvoie le signal x réverbéré en le convoluant
-%   avec la réponse impulsionnelle estimée h_est.
-%
-% Entrées :
-%   x     - signal d'entrée (vecteur monodimensionnel)
-%   h_est - réponse impulsionnelle estimée (vecteur monodimensionnel)
-%
-% Sortie :
-%   y     - signal réverbéré (longueur length(x)+length(h_est)-1)
-
-% Réverbération par convolution
-y = conv(x, h_est);
-end
\ No newline at end of file
diff --git a/src/question36.m b/src/question36.m
deleted file mode 100644
index c3f2e1fd7e858e26dbda8188da972a08308d1874..0000000000000000000000000000000000000000
--- a/src/question36.m
+++ /dev/null
@@ -1,38 +0,0 @@
-function y = effet_reverb(x, h_est)
-% EFFET_REVERB Applique un effet de réverbération par convolution
-%   y = effet_reverb(x, h_est) renvoie le signal x réverbéré en le convoluant
-%   avec la réponse impulsionnelle estimée h_est.
-%
-% Entrées :
-%   x     - signal d'entrée (vecteur monodimensionnel)
-%   h_est - réponse impulsionnelle estimée (vecteur monodimensionnel)
-%
-% Sortie :
-%   y     - signal réverbéré (longueur length(x)+length(h_est)-1)
-
-% Réverbération par convolution
-y = conv(x, h_est);
-end
-
-% 1. Chargement du signal de guitare
-[x, fe] = audioread('wav\single_tone_guitar_nylon_string_a2.wav');    % ou tout autre fichier .wav de guitare
-
-% 2. Chargement de la réponse impulsionnelle estimée
-%    (issue de la question 3.4, variable h_est dans le workspace)
-%    Assurez-vous que h_est est déjà défini avant d'appeler ce script.
-
-% 3. Mesure du temps de calcul
-tic;                     % démarre le chronomètre
-y_rev = effet_reverb(x, h_est);
-elapsed = toc;           % arrête et récupère le temps écoulé
-
-% 4. Affichage du résultat
-fprintf('Temps de calcul de effet_reverb : %.3f secondes\n', elapsed);
-
-% 5. Écoute et sauvegarde
-% soundsc(y_rev, fe);      % lecture pour vérification
-
-y_norm = y_rev / max(abs(y_rev));
-audiowrite('guitare_reverb_norm.wav', y_norm, fe);
-
-
diff --git a/src/question37.m b/src/question37.m
deleted file mode 100644
index 22545c12fcb5759a014ce4a0401df6ea622d3980..0000000000000000000000000000000000000000
--- a/src/question37.m
+++ /dev/null
@@ -1,42 +0,0 @@
-function [y_fft, elapsed] = effet_reverb_FFT(x, h_est)
-% EFFET_REVERB_FFT Filtrage par convolution rapide dans le domaine fréquentiel
-%   [y_fft, elapsed] = effet_reverb_FFT(x, h_est) renvoie le signal x filtré
-%   par h_est en utilisant fft/ifft, et mesure le temps de calcul.
-%
-% Entrées :
-%   x     - signal d'entrée (vecteur)
-%   h_est - réponse impulsionnelle estimée (vecteur)
-%
-% Sorties :
-%   y_fft  - signal réverbéré (longueur NFFT)
-%   elapsed - temps de calcul en secondes
-
-% Détermination de NFFT : longueur maximale de x et h_est
-NFFT = max(length(x), length(h_est));
-
-% Mesure du temps de calcul
-tic;
-% Transformées de Fourier
-X = fft(x, NFFT);
-H = fft(h_est, NFFT);
-% Produit fréquentiel et rétrodécomposition
-Y = X .* H;
-y_fft = ifft(Y, NFFT);
-elapsed = toc;
-end
-
-
-% Chargement / simulation déjà effectués...
-% x : signal source, h_est : réponse impulsionnelle normalisée de la pièce
-
-% Convolution directe
-tic;
-y_conv = effet_reverb(x, h_est);
-t_conv = toc;
-
-% Convolution FFT
-[y_fft, t_fft] = effet_reverb_FFT(x, h_est);
-
-% Affichage
-fprintf('Temps convolution directe : %.3f s\\n', t_conv);
-fprintf('Temps convolution FFT      : %.3f s\\n', t_fft);
\ No newline at end of file
diff --git a/src/question37_2.m b/src/question37_2.m
deleted file mode 100644
index 25695635fc597bd1acabc7cadf2dfaf866180611..0000000000000000000000000000000000000000
--- a/src/question37_2.m
+++ /dev/null
@@ -1,55 +0,0 @@
-
-function [y_fft, elapsed] = effet_reverb_FFT(x, h_est)
-% EFFET_REVERB_FFT Filtrage par convolution rapide dans le domaine fréquentiel
-%   [y_fft, elapsed] = effet_reverb_FFT(x, h_est) renvoie le signal x filtré
-%   par h_est en utilisant fft/ifft, et mesure le temps de calcul.
-%
-% Entrées :
-%   x     - signal d'entrée (vecteur)
-%   h_est - réponse impulsionnelle estimée (vecteur)
-%
-% Sorties :
-%   y_fft  - signal réverbéré (longueur NFFT)
-%   elapsed - temps de calcul en secondes
-
-% Détermination de NFFT : longueur maximale de x et h_est
-NFFT = max(length(x), length(h_est));
-
-% Mesure du temps de calcul
-tic;
-% Transformées de Fourier
-X = fft(x, NFFT);
-H = fft(h_est, NFFT);
-% Produit fréquentiel et rétrodécomposition
-Y = X .* H;
-y_fft = ifft(Y, NFFT);
-elapsed = toc;
-end
-% Chargement / simulation déjà effectués...
-% x : signal source, h_est : réponse impulsionnelle normalisée de la pièce
-function y = effet_reverb(x, h_est)
-% EFFET_REVERB Applique un effet de réverbération par convolution
-%   y = effet_reverb(x, h_est) renvoie le signal x réverbéré en le convoluant
-%   avec la réponse impulsionnelle estimée h_est.
-%
-% Entrées :
-%   x     - signal d'entrée (vecteur monodimensionnel)
-%   h_est - réponse impulsionnelle estimée (vecteur monodimensionnel)
-%
-% Sortie :
-%   y     - signal réverbéré (longueur length(x)+length(h_est)-1)
-
-% Réverbération par convolution
-y = conv(x, h_est);
-end
-% Convolution directe
-tic;
-y_conv = effet_reverb(x, h_est);
-t_conv = toc;
-
-% Convolution FFT
-[y_fft, t_fft] = effet_reverb_FFT(x, h_est);
-
-% Affichage
-fprintf('Temps convolution directe : %.3f s\n', t_conv);
-fprintf('Temps convolution FFT      : %.3f s\n', t_fft);
\ No newline at end of file
diff --git a/src/question3_12.m b/src/question3_12.m
deleted file mode 100644
index 7bf2c073d6b09ff1a09b7d3242c634b8ff897783..0000000000000000000000000000000000000000
--- a/src/question3_12.m
+++ /dev/null
@@ -1,31 +0,0 @@
-% analyse_delay.m
-% Question 3.12 : Obtention de la réponse impulsionnelle du filtre de delay via filter()
-
-% --- Paramètres de l'effet de delay ---
-fe    = 44100;               % fréquence d'échantillonnage (Hz)
-tau   = round(0.25 * fe);    % retard en échantillons (ici 0.25 s)
-g     = 0.8;                 % coefficient d'amortissement
-
-% --- Vecteurs de coefficients du filtre IIR ---
-b = 1;
-a = [1, zeros(1, tau-1), g];   % a(1)=1, a(tau+1)=g
-
-% --- Impulsion unitaire pour mesurer la réponse impulsionnelle ---
-N   = 11 * tau;              % longueur du vecteur d'impulsion (pour capturer jusqu'à 10 retards)
-x   = [1, zeros(1, N-1)];      % δ[n]
-
-% --- Calcul de la réponse impulsionnelle via filter ---
-h = filter(b, a, x);
-
-% --- Réduction et conversion en temps pour visualisation sur [0, 10τ] ---
-Lvis  = 10 * tau;
-h_vis = h(1:Lvis);
-t     = (0:Lvis-1) / fe;      % temps en secondes
-
-% --- Affichage de la réponse impulsionnelle ---
-figure;
-stem(t, h_vis, 'filled');
-grid on;
-xlabel('Temps (s)');
-ylabel('h(n)');
-title('Réponse impulsionnelle du filtre de delay sur [0, 10\tau]');
\ No newline at end of file
diff --git a/src/question5.m b/src/question5.m
deleted file mode 100644
index cdc7e79c234568a42d366df129de06152042c836..0000000000000000000000000000000000000000
--- a/src/question5.m
+++ /dev/null
@@ -1,33 +0,0 @@
-% Paramètres généraux
-fs   = 44100;      % fréquence d'échantillonnage (Hz)
-dur  = 2;          % durée du signal (s)
-N    = fs * dur;   % longueur de la FFT (choisie ici = nb d’échantillons total)
-t    = (0:N-1)/fs; % vecteur temps
-
-% Vos harmoniques et niveaux
-freqs    = [220, 442.04, 663.22, 885.05, 1117.56, 1331.46, 1556.36, 1762.92];
-amps_dB  = [-31.46, -33.80, -46.98, -45.70, -48.88, -52.17, -53.59, -67.56];
-amps_lin = 10.^(amps_dB/20);  % conversion dB → linéaire
-
-% Création du spectre complexe X
-X = zeros(N,1);  % vecteur colonne
-
-for k = 1:length(freqs)
-    % calcul de l’indice de bin correspondant
-    idx = round(freqs(k) * N / fs) + 1;
-    
-    % on distribue la même amplitude sur k et sur N−k+2 pour avoir un signal réel
-    % on multiplie par N/2 pour compenser la normalisation de l’ifft
-    X(idx)            = amps_lin(k) * (N/2);
-    X(N - idx + 2)    = amps_lin(k) * (N/2);
-end
-
-% Synthèse par IFFT
-y = ifft(X, 'symmetric');  
-
-% Normalisation (pour éviter la saturation)
-y = y / max(abs(y));
-
-% Lecture et sauvegarde
-sound(y, fs);
-audiowrite('synthese_IFFT.wav', y, fs);
\ No newline at end of file
diff --git a/src/question1.m b/src/question_1_1.m
similarity index 100%
rename from src/question1.m
rename to src/question_1_1.m
diff --git a/src/question2.m b/src/question_1_2.m
similarity index 100%
rename from src/question2.m
rename to src/question_1_2.m
diff --git a/src/question3.m b/src/question_1_3.m
similarity index 50%
rename from src/question3.m
rename to src/question_1_3.m
index be0a0a3a0c639a749ef9423af70b2005bbdb4fc2..28555fd9a8762c5a95412ae86e9fe249c4ac5a25 100644
--- a/src/question3.m
+++ b/src/question_1_3.m
@@ -1,8 +1,8 @@
-fs = 44100;            % fréquence d'échantillonnage (Hz)
-dur = 2;               % durée du signal (secondes)
-t = 0:1/fs:dur;        % vecteur temps
+fs = 44100;            
+dur = 2;               
+t = 0:1/fs:dur;   
 
-% Définir vos 8 fréquences (en Hz) et amplitudes
+% 8 fréquences (en Hz) et amplitudes
 freqs = [220, 442.04, 663.22, 885.05, 1117.56, 1331.46, 1556.36, 1762.92];
 amps_dB  = [-31.46, -33.80, -46.98, -45.70, -48.88, -52.17, -53.59, -67.56];
 amps = 10.^(amps_dB/20);
@@ -13,11 +13,8 @@ for k = 1:length(freqs)
     x = x + amps(k) * sin(2*pi*freqs(k)*t);
 end
 
-% Optionnel : normaliser pour éviter la saturation
+% Normalisation
 x = x / max(abs(x));
 
 % Lecture du son
-sound(x, fs);
-
-% (Facultatif) Enregistrer au format WAV
-audiowrite('superposition8sin.wav', x, fs);
\ No newline at end of file
+sound(x, fs);
\ No newline at end of file
diff --git a/src/question4.m b/src/question_1_4.m
similarity index 73%
rename from src/question4.m
rename to src/question_1_4.m
index 3e12d2fd3c3e9a7ac481cea1e78daedf6652301f..83b697351820c7c63e2df930cad186014456f418 100644
--- a/src/question4.m
+++ b/src/question_1_4.m
@@ -1,8 +1,8 @@
-fs = 44100;            % fréquence d'échantillonnage (Hz)
-dur = 2;               % durée du signal (secondes)
-t = 0:1/fs:dur;        % vecteur temps
+fs = 44100;            
+dur = 2;               
+t = 0:1/fs:dur;        
 
-% Définir vos 8 fréquences (en Hz) et amplitudes
+% 8 fréquences (en Hz) et amplitudes
 freqs = [220, 442.04, 663.22, 885.05, 1117.56, 1331.46, 1556.36, 1762.92];
 amps_dB  = [-31.46, -33.80, -46.98, -45.70, -48.88, -52.17, -53.59, -67.56];
 amps = 10.^(amps_dB/20);
@@ -47,16 +47,10 @@ elseif length(env) > length(t)
     env = env(1:length(t));
 end
 
-% --------------------
-% 3) Application de l'enveloppe
-% --------------------
+
+%Application de l'enveloppe
 y = x .* env;
 
-% --------------------
-% 4) Normalisation et lecture
-% --------------------
+%Normalisation et lecture
 y = y / max(abs(y));
-sound(y, fs);
-
-% (Facultatif) sauvegarde
-audiowrite('superposition8sin_ADSR.wav', y, fs);
\ No newline at end of file
+sound(y, fs);
\ No newline at end of file
diff --git a/src/question_1_5.m b/src/question_1_5.m
new file mode 100644
index 0000000000000000000000000000000000000000..2eeff47dc9bb99b0f2578137fa02e87a97f37cc5
--- /dev/null
+++ b/src/question_1_5.m
@@ -0,0 +1,28 @@
+% Paramètres généraux
+fs   = 44100;      
+dur  = 2;          
+N    = fs * dur;   
+t    = (0:N-1)/fs; 
+
+%harmoniques et niveaux
+freqs    = [220, 442.04, 663.22, 885.05, 1117.56, 1331.46, 1556.36, 1762.92];
+amps_dB  = [-31.46, -33.80, -46.98, -45.70, -48.88, -52.17, -53.59, -67.56];
+amps_lin = 10.^(amps_dB/20);
+
+% Création du spectre complexe X
+X = zeros(N,1);  % vecteur colonne
+
+for k = 1:length(freqs)
+    idx = round(freqs(k) * N / fs) + 1;
+    X(idx)            = amps_lin(k) * (N/2);
+    X(N - idx + 2)    = amps_lin(k) * (N/2);
+end
+
+% Synthèse par IFFT
+y = ifft(X, 'symmetric');  
+
+% Normalisation (pour éviter la saturation)
+y = y / max(abs(y));
+
+% Lecture
+sound(y, fs);
\ No newline at end of file
diff --git a/src/question_2_2.m b/src/question_2_2.m
new file mode 100644
index 0000000000000000000000000000000000000000..19af9f6654db15d9eba6ef75e35a7b23e14bd47e
--- /dev/null
+++ b/src/question_2_2.m
@@ -0,0 +1,25 @@
+% Paramètres
+Fs = 44100;             
+b  = [1 1]/2;            
+a  = 1;                  
+N  = 1024;              
+
+% Réponse impulsionnelle via filter
+x_imp = [1, zeros(1, N-1)];  
+h     = filter(b, a, x_imp);  
+
+% Spectre via FFT
+Hfft  = fft(h, N);
+f     = (0:N-1)/N * Fs;      
+
+% Tracé du spectre (limite à -100 dB)
+figure;
+plot(f, 20*log10(abs(Hfft)));
+hold on;
+plot(f, 20*log10(abs(cos(pi*f/Fs))), '--', 'LineWidth', 1.5);
+grid on;
+xlabel('Fréquence (Hz)');
+ylabel('Gain (dB)');
+legend('filtre simulé avec matlab', 'théorique |cos(pi* f/F_s)|');
+title('Spectre du filtre');
+ylim([-60, 0]); 
\ No newline at end of file
diff --git a/src/question_3_14.m b/src/question_3_14.m
new file mode 100644
index 0000000000000000000000000000000000000000..cee549bb3083755926f791af43d7bf7e0ef8a4ef
--- /dev/null
+++ b/src/question_3_14.m
@@ -0,0 +1,36 @@
+% 1. Paramètres du filtre
+fe    = 44100;          
+g     = 0.5;              
+tau   = 5;
+
+% Coefficients pour filter()
+b = 1;
+a = [1, zeros(1, tau-1), g];
+
+% Réponse impulsionnelle
+Nimp  = 10 * tau;                      
+delta = [1, zeros(1, Nimp-1)];        
+h     = filter(b, a, delta);
+
+% Calcul numérique du module via FFT
+Nfft = 2^18;                       
+f_norm = (0:Nfft-1)/Nfft;         
+Hnum = fft(h, Nfft);
+Hnum = abs(Hnum);
+
+% Module théorique en fréquence réduite
+omega = 2*pi * f_norm;                
+Htheo = 1 ./ abs(1 + g * exp(-1j * omega * tau));
+
+idx = (f_norm >= 0 & f_norm <= 1);
+
+% Tracé en échelle linéaire vs fréquence réduite
+figure;
+plot(f_norm(idx), Htheo(idx), 'LineWidth', 1.5); hold on;
+plot(f_norm(idx), Hnum(idx),    '--',      'LineWidth', 1);
+grid on;
+xlim([0 1]); ylim([0, 1/(1-g)+0.1]);
+xlabel('Fréquence réduite');
+ylabel('Module |H(e^{j\omega})|');
+legend('Théorique','Mesuré par FFT','Location','Best');
+title('Module linéaire de H en fréquence réduite');
\ No newline at end of file
diff --git a/src/question_3_19.m b/src/question_3_19.m
new file mode 100644
index 0000000000000000000000000000000000000000..0e6d5f5c08316f684184ac593b6084a9095d1a22
--- /dev/null
+++ b/src/question_3_19.m
@@ -0,0 +1,20 @@
+% Paramètres
+K    = 10;           
+fe   = 44100;        
+
+% Définition de h_r(k)
+h_r = ones(1, K) / K; 
+
+% Calcul de la réponse en fréquence par freqz
+Nfft = 2^14;           
+[H, f] = freqz(h_r, 1, Nfft, fe);
+
+% Tracé du module linéaire
+figure;
+plot(f, abs(H), 'LineWidth', 1.5);
+grid on;
+xlim([0 fe/2]);
+ylim([0 1.1]);
+xlabel('Fréquence (Hz)');
+ylabel('Module |H_r(e^{j\omega})|');
+title('Réponse en fréquence du filtre de boucle moyenne glissante');
\ No newline at end of file
diff --git a/src/question3_3.m b/src/question_3_3.m
similarity index 100%
rename from src/question3_3.m
rename to src/question_3_3.m
diff --git a/src/question_3_4.m b/src/question_3_4.m
new file mode 100644
index 0000000000000000000000000000000000000000..ad4700de65c30a03e4751559baeb625b89f6c107
--- /dev/null
+++ b/src/question_3_4.m
@@ -0,0 +1,24 @@
+
+load('signal_excitation.mat');   
+x = xe1;                         
+y = simule_piece(x, fe);
+[r, lags] = xcorr(y, x);
+
+Lh = 80000;                   
+i0 = find(lags == 0);         
+h_est = r(i0 : i0 + Lh - 1);  
+
+% Normalisation de la réponse impulsionnelle
+h_est = h_est / max(abs(h_est));  
+
+% Vecteur temps
+Te  = 1/fe;                       
+t_h = (0:Lh-1) * Te;             
+
+% Affichage de la réponse normalisée
+figure;
+plot(t_h, h_est, 'b');
+grid on;
+xlabel('Temps t (s)');
+ylabel('h_{est,norm}(t)');
+title('Réponse impulsionnelle estimée et normalisée de la pièce');
\ No newline at end of file
diff --git a/src/question_3_7.m b/src/question_3_7.m
new file mode 100644
index 0000000000000000000000000000000000000000..32962ddded236421a2aeaa0906d031bf10ea6110
--- /dev/null
+++ b/src/question_3_7.m
@@ -0,0 +1,11 @@
+% Convolution directe
+tic;
+y_conv = effet_reverb(x, h_est);
+t_conv = toc;
+
+% Convolution FFT
+[y_fft, t_fft] = effet_reverb_FFT(x, h_est);
+
+% Affichage
+fprintf('Temps convolution directe : %.3f s\n', t_conv);
+fprintf('Temps convolution FFT     : %.3f s\n', t_fft);
\ No newline at end of file
diff --git a/src/simule_piece.m b/src/simule_piece.m
index 6cd4b05366a95bae0d4537f453ca3983089aecaf..0f7a859854693c5697319123494d28dc6d181ea9 100644
--- a/src/simule_piece.m
+++ b/src/simule_piece.m
@@ -1,4 +1,4 @@
-function [ y ] = simule_pieces( x,fech )
+function [ y ] = simule_piece( x,fech )
 %ENTREE : x=signal émis par le haut-parleur
 %         fech=fréquence d'échantillonnage de x
 %SORTIE : y=signal capté par le microphone dans la pièce
@@ -9,28 +9,4 @@ if fech~=fe, error('Fréquence d''échantillonnage incorrecte'), end
 empreinte=empreinte(1:80000);
 y=conv(x,empreinte);
 
-end
-
-load('signal_excitation.mat');   % fournit xe1, xe2 et fe
-x = xe1;                         % on prend xe1 (δ-like)
-y = simule_pieces(x, fe);
-[r, lags] = xcorr(y, x);
-
-Lh = 80000;                   % longueur de l'empreinte interne
-i0 = find(lags == 0);         % index correspondant à lag = 0
-h_est = r(i0 : i0 + Lh - 1);  % h_est[n] ≈ R_yx[-n] pour n=0…Lh-1
-
-% --- Normalisation de la réponse impulsionnelle ---
-h_est = h_est / max(abs(h_est));  % mise à l'échelle pour que |h_est|_max = 1
-
-% --- Vecteur temps ---
-Te  = 1/fe;                       % période d'échantillonnage
-t_h = (0:Lh-1) * Te;              % vecteur temps en secondes
-
-% --- Affichage de la réponse normalisée ---
-figure;
-plot(t_h, h_est, 'b');
-grid on;
-xlabel('Temps t (s)');
-ylabel('h_{est,norm}(t)');
-title('Réponse impulsionnelle estimée et normalisée de la pièce');
+end
\ No newline at end of file
diff --git a/src/test_effet_delay.m b/src/test_effet_delay.m
new file mode 100644
index 0000000000000000000000000000000000000000..9bd34d2606094f84f938d376f368269f58459e00
--- /dev/null
+++ b/src/test_effet_delay.m
@@ -0,0 +1,12 @@
+% Chargement du signal de piano
+[x, fe] = audioread('wav/single_tone_piano2.wav'); o
+
+% Paramètres de l’effet
+tau = round(0.25 * fe);      
+g      = 0.9;          
+
+% Application de la fonction effet_delay
+y = effet_delay(x, tau, g, fe);  
+
+% 4. Écoute et sauvegarde
+soundsc(y, fe);                 
diff --git a/src/test_effet_delay_filtre.m b/src/test_effet_delay_filtre.m
new file mode 100644
index 0000000000000000000000000000000000000000..b1ff4fc588c49a8aa24af601364fec0350223697
--- /dev/null
+++ b/src/test_effet_delay_filtre.m
@@ -0,0 +1,21 @@
+% Chargement du signal de piano
+[x, fe] = audioread('wav/single_tone_piano2.wav');  
+x = x(:);                            
+
+% Paramètres de l'effet
+t_delay = 0.25; 
+g       = 0.9;   
+K       = 10;    
+
+% Application de l'effet avec filtre dans la boucle
+y = effet_delay_filtre(x, t_delay, g, K, fe);
+
+% Écoute du résultat
+soundsc(y, fe);
+
+% 5. Sauvegarde du signal traité
+audiowrite('piano_delay_filtre.wav', y, fe);
+
+% Affichage rapide des paramètres et durée
+fprintf('Effet delay+filtre : t_delay=%.3fs, g=%.2f, K=%d\n', t_delay, g, K);
+fprintf('Durée du signal traité : %.2f s\n', length(y)/fe);
diff --git a/src/test_effet_reverb.m b/src/test_effet_reverb.m
new file mode 100644
index 0000000000000000000000000000000000000000..e243331b011612618d0cf1dcf75eb8645bddda13
--- /dev/null
+++ b/src/test_effet_reverb.m
@@ -0,0 +1,15 @@
+% Chargement du signal de guitare
+[x, fe] = audioread('wav\single_tone_guitar_nylon_string_a2.wav');    % ou tout autre fichier .wav de guitare
+
+% Mesure du temps de calcul
+tic; 
+y_rev = effet_reverb(x, h_est);
+elapsed = toc;
+
+% Affichage du résultat
+fprintf('Temps de calcul de effet_reverb : %.3f secondes\n', elapsed);
+
+% Écoute
+soundsc(y_rev, fe);
+
+