M1103 – TP1 – Exercice 1

Ajoutez cet alias après la déclaration de l’utilisation de l’espace de nom standard :

typedef vector <unsigned> CVUint;

Ecrivez la procédure SelectSort () du signature

void SelectSort (CVUint & VUint);

Cette procédure trie le vecteur en paramètre selon la méthode du tri par sélection / échange (cf. M1103 TD1 – eox1).

Afin d’initialiser votre vecteur, ajouter ces lignes dans le main () :

#include <cstdlib>
#include <ctime>
...
srand (time(NULL));
CVUint VUInt (XXX);

for (auto & Val : VUInt)
     Val = rand () % (VUInt.size() * 10);

Pour finir, écrivez la fonction TestVecteurTrié () de signature

void TestVecteurTrie (const CVUint & VUint);

Cette fonction doit tester si le vecteur qui lui est passé en paramètre est trié. Cette vérification doit de faire à l’aide de la fonction assert ().

NB : pensez à mettre un message à la fin de votre fonction TestVecteurTrié () pour vous assurez que vous passez tous les tests.

M1103 – TP1 – Exercice 4

Insérer dans le code suivant vos algorithmes de tri.
Modifier le .pro en ajoutant la ligne LIBS += -pthread

Puis faite divers tests en faisant varier les paramètres d’entrée :

  1. la taille des vecteurs;
  2. le nombre de vecteurs différents;
  3. nombre d’itérations par vecteur;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iomanip&gt;
#include &lt;cstdlib&gt;
#include &lt;ctime&gt;
#include &lt;algorithm&gt;
#include &lt;thread&gt;

using namespace std;

typedef vector &lt;unsigned&gt; CVUint;
typedef vector &lt; vector &lt;double&gt;&gt; CMatrix;

CMatrix Mat;

void SelectSort (CVUint &amp; VUint)
{
//todo
}

void InsertSort (CVUint &amp; VUint)
{
//todo
}

void BubbleSort (CVUint &amp; VUint)
{
//todo
}

void LanguageSort (CVUint &amp; VUint)
{
    sort (VUint.begin(), VUint.end());
}

void InitMat (unsigned NbColumns)
{
    Mat.resize(4, vector &lt;double&gt; (NbColumns));
}

//http://stackoverflow.com/questions/2962785/c-using-clock-to-measure-time-in-multi-threaded-programs
void protoGenericSort(void (*Sort) (CVUint &amp; VUint), const CVUint &amp; VUint, unsigned NbFois, unsigned PosMat, unsigned VectNum)
{
    for (unsigned i (0); i &lt; NbFois; ++i)
    {
        CVUint CopyVUint (VUint);
        struct timespec start, finish;
        double elapsed;
        clock_gettime(CLOCK_MONOTONIC, &amp;start);
        Sort (CopyVUint);
        clock_gettime(CLOCK_MONOTONIC, &amp;finish);
        elapsed = (finish.tv_sec - start.tv_sec);
        elapsed += (finish.tv_nsec - start.tv_nsec) / 1000000000.0;
        Mat [PosMat][i + NbFois * VectNum] = elapsed;
    }
}

void TraiterResultats (const unsigned &amp; NbElemAEnlever)
{
    for (vector &lt;double&gt; &amp; UneLigne : Mat)
    {
        //tri
        sort (UneLigne.begin(), UneLigne.end());
        //suppresion des éléments non significatifs
        UneLigne = vector &lt;double&gt; (UneLigne.begin() + NbElemAEnlever / 2, UneLigne.end() - NbElemAEnlever / 2 );
        //plus petit temps
        double min (UneLigne[0]);
        //plus grand temps
        double max (UneLigne[UneLigne.size()-1]);
        //temps median
        double med (UneLigne[UneLigne.size()/2]);

        //On assigne les valeurs memorisees aux 3 premières cases
        UneLigne[0] = min;
        UneLigne[1] = med;
        UneLigne [2] = max;
    }
    //Affichage
    cout &lt;&lt; setw (20) &lt;&lt; "Tri" &lt;&lt; setw (10) &lt;&lt; "Min" &lt;&lt; setw (10) &lt;&lt; "Med" &lt;&lt; setw (10) &lt;&lt; "Max" &lt;&lt; endl;
    vector&lt;string&gt; VMetode {"Selection", "Insertion", "Bulles", "Langage"};
    for (unsigned i (0); i &lt; VMetode.size(); ++i)
        cout &lt;&lt; setw (20) &lt;&lt; VMetode[i] &lt;&lt; setw (10) &lt;&lt; setprecision(6) &lt;&lt; Mat[i][0] &lt;&lt; setw (10) &lt;&lt; setprecision(6) &lt;&lt; Mat[i][1] &lt;&lt; setw (10) &lt;&lt; setprecision(6) &lt;&lt; Mat[i][2] &lt;&lt; endl;

}

int main(int argc, char *argv[])
{
    if (argc != 4)
    {
        cerr &lt;&lt; "boulette !\n utilisation : " &lt;&lt; argv [0] &lt;&lt; " (1) NbElem par vecteur (2) Nb de vecteurs differents (3) Nb itérations par vecteur" &lt;&lt; endl;
        return 1;
    }

    unsigned NbElem (stoul(argv[1]));
    unsigned NbVecteurs (stoul(argv[2]));
    unsigned NbFois (stoul(argv[3]));

    srand (time(NULL));
    CVUint VUInt (NbElem);
    InitMat(NbFois * NbVecteurs);

    for (unsigned i (0); i &lt; NbVecteurs; ++i)
    {
        for (auto &amp; Val : VUInt)
            Val = rand () % (VUInt.size() * 10);

        thread th1 (protoGenericSort,SelectSort, VUInt, NbFois, 0, i);
        thread th2 (protoGenericSort, InsertSort, VUInt, NbFois, 1, i);
        thread th3 (protoGenericSort, BubbleSort, VUInt, NbFois, 2, i);
        thread th4 (protoGenericSort, LanguageSort, VUInt, NbFois, 3, i);
        th1.join();
        th2.join();
        th3.join();
        th4.join();
        cout &lt;&lt; i &lt;&lt; "fini" &lt;&lt; endl;
    }

    cout &lt;&lt; "Taille des vecteurs : " &lt;&lt; NbElem &lt;&lt; "\nNb de vecteurs : " &lt;&lt; NbVecteurs &lt;&lt; "\nNb iterations par vecteur : " &lt;&lt; NbFois &lt;&lt; endl;
    TraiterResultats (NbFois * NbVecteurs / 10);
    return 0;
}

M1103-TP21 Corrigé

#include 
#include 
#include 
#include 
#include 
#include 
#include 


using namespace std;

typedef vector  CVUint;
typedef vector < vector > CMatrix;

CMatrix Mat;

void SelectSort (CVUint & VUint)
{
    for (unsigned i (0); i < VUint.size(); ++i)
    {
        CVUint::iterator Min (min_element (VUint.begin() + i, VUint.end()));
        swap (VUint[i],VUint [Min - VUint.begin()]);
    }
}

void InsertSort (CVUint & VUint)
{
    for (unsigned i (1); i < VUint.size(); ++i)
    {
        unsigned Val (VUint [i]);
        unsigned j (i);
        for (; j > 0 && VUint[j - 1] > Val; --j)
            VUint[j] = VUint[j - 1];
        VUint[j] = Val;
    }
}

void BubbleSort (CVUint & VUint)
{
    for (unsigned i (VUint.size()); i -- > 0; )
    {
        bool TableauTrie = true;
        for (unsigned j (0); j < i ; ++j)
        {
            if (VUint[j + 1] < VUint[j])
            {
                swap (VUint[j + 1], VUint[j]);
                TableauTrie = false;
            }
        }
        if (TableauTrie) return;
    }
}

void LanguageSort (CVUint & VUint)
{
    sort (VUint.begin(), VUint.end());
}

void InitMat (unsigned NbColumns)
{
    Mat.resize(4, vector  (NbColumns));
}

//http://stackoverflow.com/questions/2962785/c-using-clock-to-measure-time-in-multi-threaded-programs
void protoGenericSort(void (*Sort) (CVUint & VUint), const CVUint & VUint, unsigned NbFois, unsigned PosMat, unsigned VectNum)
{
    for (unsigned i (0); i < NbFois; ++i)
    {
        CVUint CopyVUint (VUint);
        struct timespec start, finish;
        double elapsed;
        clock_gettime(CLOCK_MONOTONIC, &start);
        Sort (CopyVUint);
        clock_gettime(CLOCK_MONOTONIC, &finish);
        elapsed = (finish.tv_sec - start.tv_sec);
        elapsed += (finish.tv_nsec - start.tv_nsec) / 1000000000.0;
        Mat [PosMat][i + NbFois * VectNum] = elapsed;
    }
}

void TraiterResultats (const unsigned & NbElemAEnlever)
{
    for (vector  & UneLigne : Mat)
    {
        //tri
        sort (UneLigne.begin(), UneLigne.end());
        //suppresion des éléments non significatifs
        UneLigne = vector  (UneLigne.begin() + NbElemAEnlever / 2, UneLigne.end() - NbElemAEnlever / 2 );
        //plus petit temps
        double min (UneLigne[0]);
        //plus grand temps
        double max (UneLigne[UneLigne.size()-1]);
        //temps median
        double med (UneLigne[UneLigne.size()/2]);

        //On assigne les valeurs memorisees aux 3 premières cases
        UneLigne[0] = min;
        UneLigne[1] = med;
        UneLigne [2] = max;
    }
    //Affichage
    cout << setw (20) << "Tri" << setw (10) << "Min" << setw (10) << "Med" << setw (10) << "Max" << endl;
    vector VMetode {"Selection", "Insertion", "Bulles", "Langage"};
    for (unsigned i (0); i < VMetode.size(); ++i)
        cout << setw (20) << VMetode[i] << setw (10) << setprecision(6) << Mat[i][0] << setw (10) << setprecision(6) << Mat[i][1] << setw (10) << setprecision(6) << Mat[i][2] << endl;

}

int main(int argc, char *argv[])
{
    if (argc != 4)
    {
        cerr << "boulette !\n utilisation : " << argv [0] << " (1) NbElem par vecteur (2) Nb de vecteurs differents (3) Nb itérations par vecteur" << endl;
        return 1;
    }

    unsigned NbElem (stoul(argv[1]));
    unsigned NbVecteurs (stoul(argv[2]));
    unsigned NbFois (stoul(argv[3]));

    srand (time(NULL));
    CVUint VUInt (NbElem);
    InitMat(NbFois * NbVecteurs);


    for (unsigned i (0); i < NbVecteurs; ++i)
    {
        for (auto & Val : VUInt)
            Val = rand () % (VUInt.size() * 10);

        thread th1 (protoGenericSort,SelectSort, VUInt, NbFois, 0, i);
        thread th2 (protoGenericSort, InsertSort, VUInt, NbFois, 1, i);
        thread th3 (protoGenericSort, BubbleSort, VUInt, NbFois, 2, i);
        thread th4 (protoGenericSort, LanguageSort, VUInt, NbFois, 3, i);
        th1.join();
        th2.join();
        th3.join();
        th4.join();
        cout << i << "fini" << endl;
    }

    cout << "Taille des vecteurs : " << NbElem << "\nNb de vecteurs : " << NbVecteurs << "\nNb iterations par vecteur : " << NbFois << endl;
    //On traite les résultats en supprimant 10% des éléments
    TraiterResultats (NbFois * NbVecteurs / 10);
    return 0;
}