AlgoModel.tex

% \begin{tabbing}

% \ul{fonction} analyser(frequences : \ul{tableau entier}[0..n], n : \ul{entier}, seuilMin : \ul{entier}) : \ul{tableau Accord}\\
% \ul{debut}\\
% frequences <- trier(frequences)\\
% i <- 0\\
% complet <- faux\\
% \ul{Tant que} i < n \ul{et} \ul{non} complet \ul{faire}\\
%     freq <- frequences[i]\\
%     \ul{Si} freq > seuilMin \ul{et} \ul{non} present(retour, freq)\\
%     \ul{alors}\\
%         ajouter(retour, freq)\\
%         \ul{Si} taille(retour) > 5\\
%         \ul{alors}\\
%             complet <- vrai\\
%         \ul{fsi}\\
%     \ul{fsi}\\
% \ul{ftantque}\\
% \ul{retourne} retour\\
% \ul{fin}\\
% \end{tabbing}
% \newline
% \ul{lexique}\newline

\ul{Structures de donnees utilisees dans les algorithmes:}\newline
\ul{Note} < frequence : \ul{entier}, nom : \ul{chaine} >\newline
\ul{EntreeMicro} : Type correspondant à l'entrée micro de l'ordinateur. Il permet de récupérer les fréquences à un certain instant\newline
\ul{Accord} : < notes : \ul{tableau Note}[0..6] , courant : \ul{entier}>\newline
\ul{Partition} : < accords : \ul{Liste(Accord)} >\newline
\ul{Gamme} : < notes : \ul{Liste(Note)}>\newline
% Algo de récupérer une note avec sa fréquence
Récupérer une note grâce à sa fréquence\newline
\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} recupererNote(frequence : \ul{entier}, notes : \ul{Note[0..n]}, n : \ul{entier}) : Note\\
\ul{debut}\\
\>min <- 0\\
\>max <- n\\
\>trouve <- faux\\
\>\ul{Tant que} min <= max \ul{et} \ul{non} trouve \ul{faire}\\
    \>\>indice <- (max + min) /2 \\
    \>\>frequenceNote <- notes[indice].frequence\\
    \>\>\ul{Si} frequence = frequenceNote\\
    \>\>\ul{alors}\\
        \>\>\>retour <- notes[indice]\\
        \>\>\>trouve <- vrai\\
    \>\>\ul{sinon}\\
        \>\>\>\ul{Si} frequence < frequenceNote\\
        \>\>\>\ul{alors}\\
            \>\>\>\>max <- indice\\
        \>\>\>\ul{sinon}\\
            \>\>\>\>min <- indice\\
        \>\>\>\ul{fsi}\\
    \>\>\ul{fsi}\\
\>\ul{ftantque}\\
\>\ul{Si} \ul{non} trouve\\
\>\ul{alors}\\
    \>\>retour <- notes[min]\\
\>\ul{fsi}\\
\>\ul{retourne} retour\\
\ul{fin}\\
\end{tabbing}
\ul{lexique}\newline
frequence : \ul{entier} : Fréquences de la note à récupérer\newline
notes : \ul{Note[0..n]} : Toutes les notes possibles\newline
n :  \ul{entier} : Nombre de notes possibles\newline
max : \ul{entier} : indice maximal dans le tableau\newline
min : \ul{entier} : indice minimal dans le tableau\newline
trouve : \ul{booleen} : Booléen à vrai si on a trouvé la note (avec exactement la même fréquence)\newline
indice : \ul{entier} : Indice en cours dans le tableau\newline
frequenceNote : \ul{entier} : Frequence de la note en cours d'analyse\newline
retour : \ul{Note} : Note correspondant à la fréquence\newline

Fonction de placement nécessaire à la fonction trier\newline

\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} placer(meta : \ul{tableau entier}[0..n], frequences : \ul{tableau entier}[0..n], n : \ul{entier}, inf : \ul{entier}, sup : \ul{entier}) : \ul{entier}\\
\ul{debut}\\
    \>inda <- inf\\
    \>a <- frequences[meta[inf]]\\
    \>inf <- inf + 1\\
    \>\ul{Tant que } sup >= inf \ul{faire}\\
        \>\>\ul{Si} frequences[meta[inf]] > a\\
        \>\>\ul{alors}\\
            \>\>\>\ul{Tant que} sup >= inf \ul{ou} frequences[meta[[sup]] > a \ul{faire}\\
                \>\>\>\>sup <- sup - 1\\
            \>\>\>\ul{ftantque}\\
            \>\>\>temp <- meta[sup]\\
            \>\>\>meta[sup] <- meta[inf]\\
            \>\>\>meta[inf] <- temp\\
            \>\>\>sup <- sup - 1\\
        \>\>\ul{fsi}\\
        \>\>inf <- inf + 1\\
    \>\ul{ftantque}\\
    \>temp <- meta[sup]\\
    \>meta[sup] <- meta[inda]\\
    \>meta[inda] <- temp\\
    \>\ul{retourne} sup\\
\ul{fin}\\
\end{tabbing}

\ul{lexique}\newline
meta : \ul{tableau entier}[0..n] : Meta donnée contenant les numéros de frequences\newline
frequences : \ul{tableau entier}[0..n] : Les indices sont les numéros de fréquences et les valeurs sont le volume\newline
n : \ul{entier} : Taille des tableaux frequences et meta\newline
inf : \ul{entier} : Borne inférieur utilisée pour le placement\newline
sup : \ul{entier} : Borne supérieure utilisée pour le placement\newline
inda : \ul{entier} : Valeur de inf avant modification\newline
a : \ul{entier} : Valeur du volume de la fréquence\newline
temp : \ul{entier} : Variable temporaire\newline


Fonction de tri des fréquences\newline
\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} trier(meta : \ul{tableau entier}[0..n], frequences : \ul{tableau entier}[0..n], n : \ul{entier}, inf : \ul{entier}, sup : \ul{entier})\\
\ul{debut}\\
    \>\ul{Si} inf < sup\\
    \>\ul{alors}\\
        \>\>indice <- placer(meta, frequences, inf, sup)\\
        \>\>trier(meta, frequences, n, inf, indice - 1)\\
        \>\>trier(meta, frequences, n, indice + 1, sup)\\
    \>\ul{fsi}\\
\ul{fin}\\ 
\end{tabbing}
\ul{lexique}\newline
meta : \ul{tableau entier}[0..n] : Meta donnée contenant les numéros de frequences\newline
frequences : \ul{tableau entier}[0..n] : Les indices sont les numéros de fréquences et les valeurs sont le volume\newline
n : \ul{entier} : Taille des tableaux frequences et meta\newline
inf : \ul{entier} : Borne inférieur utilisée pour le tri\newline
sup : \ul{entier} : Borne supérieure utilisée pour le tri\newline
indice : \ul{entier} : Indice retournée par le placement pour diviser le tableau\newline

Montrer la note principale(pour l'accordeur)\newline
\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} montrerNote(mic : \ul{entreeMicro})\\
\ul{debut}\\
\>accorder <- vrai\\
\>\ul{Tant que}\\
    \>\>n <- 512\\
    \>\>freqs <- recupererFrequences(mic, n)\\
    \>\>\ul{Pour} i \ul{de} 0 \ul{a} n \ul{faire}\\
        \>\>\>meta[i] <- i\\
    \>\>\ul{fpour}\\
    \>\>meta <- trier(meta, freqs, n, 0, n - 1)\\
    \>\>\ul{ecrire} recupererNote(meta[0])\\
\>\ul{ftantque}\\
\ul{fin}\\
\end{tabbing}

\ul{lexique}\newline
mic : \ul{entreeMicro} : Entrée micro utilisée\newline
accorder : \ul{booleen} : Booleen à vrai si on continue à accorder. Il peut être changer grâce à un clic dans l'application\newline
freqs : freqs : \ul{tableau entier}[0..n] : Frequences envoyées par mic\newline
\newline

Enregistrement d'une partition\newline
%Enregistrement d'une partition
\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} enregistrer(mic : \ul{entreeMicro}, seuilHaut :  \ul{entier}, seuilBas : \ul{entier}, tempo : \ul{entier}) : \ul{Partition}\\
\ul{debut}\\
\>enregistrer <- vrai\\
\>j <- 0\\
\>accord <- accordVide() //Renvoi un accord vide\\
\>\ul{Tant que} enregistrer \ul{faire}\\
    \>\>frequences <- recupererFrequences(mic)\\
    \>\>n <- 512\\
    \>\>freqs <- recupererFrequences(mic, n)\\
    \>\>\ul{Pour} i \ul{de} 0 \ul{a} n \ul{faire}\\
        \>\>\>meta[i] <- i\\
    \>\>\ul{fpour}\\
    \>\>meta <- trier(meta, frequences, n, 0, n - 1)\\
    \>\>complet <- faux\\
    \>\>fini <- faux\\
    \>\>i <- 0 \\
    \>\>new <- false\\
    \>\>\ul{Tant que} \ul{non} complet \ul{et} \ul{non} fini \ul{faire}\\
        \>\>\>indiceFrequence <- meta[i]\\
        \>\>\>frequence <- frequences[indiceFrequence]\\
        \>\>\>\ul{si} frequence > seuilHaut\\
        \>\>\>\ul{alors}\\
            \>\>\>\>new <- vrai\\
            \>\>\>\>ajouterAccord(partition, accord)\\
            \>\>\>\>accord <- accordVide()\\
            \>\>\>\>complet <- ajouterNote(accord, recupererNote(frequence)\\
        \>\>\>\ul{sinon}\\
            \>\>\>\>\ul{si} \ul{non} new\\
            \>\>\>\>\ul{alors}\\
                \>\>\>\>\>\ul{Si} frequence > seuilBas\\
                \>\>\>\>\>\ul{alors}\\
                    \>\>\>\>\>\>acc <- accordVide()\\
                    \>\>\>\>\>\>complet <- ajouterNote(accord, recupererNote(frequence))\\
                \>\>\>\>\>\ul{sinon}\\
                    \>\>\>\>\>\>fini <- vrai\\
                \>\>\>\>\>\ul{fsi}\\
            \>\>\>\>\ul{sinon}\\
                \>\>\>\>\>fini <- vrai\\
            \>\>\>\>\ul{fsi}\\
        % \>\>\>indiceFrequence <- meta[i]\\
        % \>\>\>\ul{si} frequences[indiceFrequence] > seuilHaut\\
        % \>\>\>\ul{alors}\\
        %     \>\>\>\>ajouterNote(recupereNote(frequences[indiceFrequence], accord)\\
        %     \>\>\>\>new <- \ul{vrai}\\
        %     \>\>\>\>j <- j + 1\\
        % \>\>\>\ul{sinon}\\
        %     \>\>\>\>\ul{si} frequence > seuilBas\\
        %     \>\>\>\>\ul{alors}\\ 
        %         \>\>\>\>\>ajouterTemps(retour[j], tempo / 16)\\
        %     \>\>\>\>\ul{sinon}\\
        %         \>\>\>\>\>fini <- vrai\\
        %     \>\>\>\>\ul{fsi}\\
        % \>\>\>\ul{fsi}
    \>\>\ul{ftantque}\\     
    \>\>\ul{Si} \ul{non} new\\
    \>\>\ul{alors}\\
        \>\>\>\ul{si} \ul{non} estVide(acc)\\
        \>\>\>\ul{alors}\\
            \>\>\>\>\ul{si} acc = accord\\
            \>\>\>\>\ul{alors}\\
                \>\>\>\>\>ajouterTemps(1000 / tempo / 16)\\
            \>\>\>\>\ul{fsi}\\
        \>\>\>\ul{fsi}\\
    \>\>\ul{fsi}\\
    \>\>i <- i + 1\\  
    \>\>attendre(1000 / tempo / 16)\\
\>\ul{ftantque}\\
\>\ul{retourne} retour \\
\ul{fin}\\
\end{tabbing}

Nous attendons pendant 1000 / tempo / 16 car c'est la plus petite unité de temps représentable dans une partition. L'utilisateur doit rentrer le tempo dans lequel il compte jouer.
Nous attendons en milliseconde.


\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} ajouterNote(accord : \ul{Accord}, note : \ul{Note}) : \ul{booleen}\\ 
\ul{debut}\\
    \>\ul{si} accord.courant = 5\\
    \>\ul{alors}\\
        \>\>retour <- vrai\\
    \>\ul{sinon}\\
        \>\>accord[courant] = note\\
        \>\>accord.courant <- accord.courant + 1\\
    \>\ul{fsi}\\
    \>\ul{retourne} retour\\ 
\ul{fin}\\
\end{tabbing}

\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} ajouterAccord(partition : \ul{Partition}, accord : \ul{Accord})\\
\ul{debut}\\
    \>adjqlis(partition, accord)\\
\ul{fin}\\
\end{tabbing}


\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} analyserGamme(partition : \ul{Partition}, gammes : \ul{tableau Gamme}[0..n], n : \ul{entier}) : Gamme\\
\ul{debut}\\
    % \>//On compte toute les notes\\
    \>notes <- partition.notes\\
    \>indice <- tete(notes)\\
    \>\ul{Tant que} \ul{non} finliste(notes, indice) \ul{faire}\\
        \>\>accord <- val(notes, indice)\\
        \>\>\ul{Pour chaque} note \ul{dans} accord \ul{faire}\\
            \>\>\>tnotes[note] <- tnotes[note] + 1\\
        \>\>\ul{fpourchaque}\\
        indice <- suc(notes, indice)\\
    \>\ul{ftantque}\\

    % \>trierNotes(notes)\\
    \>\ul{Pour} i \ul{de} 0 \ul{a} n \ul{faire}\\
        \>\>gamme <- gammes[i]\\
        \>\>pourcentage[i] <- pourcentageGamme(gamme, tnotes)\\
    \>\ul{fpour}\\
    pourcentMax <- 0\\
    \>\ul{Pour} i \ul{de} 0 \ul{a} n \ul{faire}\\
        \>\>\ul{si} pourcentage[i] > pourcentMax\\
        \>\>\ul{alors}\\
            \>\>\>gammeMax <- gammes[i]\\
        \>\>\ul{fsi}\\
    \>\ul{fpour}\\

    \>\ul{retourne} gammeMax\\
\ul{fin}\\
\end{tabbing}

Algorithme utilisé pour déterminer combien il y a de notes d'une gamme dans un ensemble de notes\newline
\begin{tabbing}
\kill XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=XX\=
\kill
\ul{fonction} pourcentageGamme(gamme : \ul{Gamme}, notes : \ul{table (Note => entier)}) : \ul{entier}\\
\ul{debut}\\
    \>indice <- tete(gamme)\\
    \>nbNotesGammes <- 0\\
    \>\ul{Tant que} \ul{non} finliste(gamme, indice) \ul{faire}\\
        \>\>note <- val(gamme, indice)\\
        \>\>nbNotesGammes <- nbNotesGammes + accestab(notes, note)\\
    \>\ul{ftantque}\\
    \>nbTotal <- 0\\
    \>\ul{Pour chaque} valeur \ul{dans} \ul{notes} \ul{faire}\\
        \>\>nbTotal <- nbTotal + valeur\\
    \>\ul{fpourchaque}\\
    \>\ul{retourne} (nbNotesGammes / nbTotal ) * 100\\
\ul{fin}\\
\end{tabbing}