ajout travail control machine kara-mosr

EX1.c

@@ -0,0 +1,193 @@
+/*Je me suis pas super bien organise le fichierest long pour rien le main est trop long
+Je me suis lancer dans l'utilisation d'allocation et de pointeur ce qui etat peut etre pas necessaire
+j'ai essayer de commenter et de bien expliquer dans reponses.txt pour que ca reste comprehensible
+Et puis dans le main j'ai mis pas mal de printf qui devrait aider la comprehension a l'execution
+
+Pour compiler :
+gcc -pg -o ex1 EX1.c
+./ex1
+gprof ./ex1
+
+Riad Kara-Mostefa
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+
+
+int racineCarree(int n) {
+    if (n < 0) return -1;
+    if (n == 0 || n == 1) return n;
+
+    int i = 1;
+    while (i <= n / i) {
+        if ((n % i == 0) && (i == n / i)) {
+            return i;
+        }
+        i++;
+    }
+    return -1;
+}
+
+void racineCarreeTab(const int *in, int *out, size_t size) {
+    for (size_t i = 0; i < size; ++i) {
+        out[i] = racineCarree(in[i]);
+    }
+}
+
+static void affichageTab(const char *label, const int *t, size_t n) {
+    printf("%s[", label);
+    for (size_t i = 0; i < n; ++i) {
+        if (i) printf(",");
+        printf("%d", t[i]);
+    }
+    printf("]\n");
+}
+
+
+static void affichageTabLL(const char *label, const long long *t, size_t n) {
+    printf("%s[", label);
+    for (size_t i = 0; i < n; ++i) {
+        if (i) printf(",");
+        printf("%lld", t[i]);
+    }
+    printf("]\n");
+}
+
+
+void TriSpecial(const int *in, size_t n, long long *out) {
+    if (!in || !out || n == 0) return;
+/*some original et some des racines*/
+    long long SommeOrigine = 0;
+    long long SommeSqrt = 0;
+    size_t nbNonEntieres = 0;
+/* tab avec les racines carees*/
+    int *roots = (int*)malloc(n * sizeof(int));
+    if (!roots) {
+        for (size_t i = 0; i < n; ++i) {
+            int r = racineCarree(in[i]);
+            SommeOrigine += (long long)in[i];
+            SommeSqrt += (long long)r;
+            if (r == -1) ++nbNonEntieres;
+        }
+        roots = NULL;
+    } else {
+        for (size_t i = 0; i < n; ++i) {
+            int r = racineCarree(in[i]);
+            roots[i] = r;
+            SommeOrigine += (long long)in[i];
+            SommeSqrt += (long long)r;
+            if (r == -1) ++nbNonEntieres;
+        }
+    }
+
+    const int pair = ((nbNonEntieres % 2) == 0);
+
+    if (pair) {
+        for (size_t i = 0; i < n; ++i) {
+            if ((i % 2) == 0) out[i] = (long long)in[i];
+            else              out[i] = SommeOrigine * (long long)in[i];
+        }
+    } else {
+        for (size_t i = 0; i < n; ++i) {
+            if ((i % 2) == 0) {
+                int r = roots ? roots[i] : racineCarree(in[i]);
+                out[i] = (long long)r;
+            } else {
+                out[i] = SommeSqrt * (long long)in[i];
+            }
+        }
+    }
+
+    free(roots);
+}
+
+int main(void) {
+    printf("EX1 : tests simples\n");
+    printf("racineCarree(9)  = %d\n",  racineCarree(9));
+    printf("racineCarree(10) = %d\n", racineCarree(10));
+
+    int t1[] = {9,25,4};
+    int r1[3];
+    racineCarreeTab(t1, r1, 3);
+    affichageTab("racineCarreeTab([9,25,4]) = ", r1, 3);
+
+    int t2[] = {10,36,2};
+    int r2[3];
+    racineCarreeTab(t2, r2, 3);
+    affichageTab("racineCarreeTab([10,36,2]) = ", r2, 3);
+
+    /* le gros tableau de test comme demande dans l'exo2 */
+    printf("\nEX2 : gros tableau (racineCarreeTab) \n");
+    const size_t N = 10000;
+    int *big = (int*)malloc(sizeof(int) * N);
+    int *res = (int*)malloc(sizeof(int) * N);
+    /*je verifie l'allocation memeoire*/
+    if (!big || !res) {
+        fprintf(stderr, "Allocation echouee pour EX2\n");
+        free(big); free(res);
+        return 1;
+    }
+
+    /* J'ai essaye de genere des carre parfait et des non-carres on va dire pour tester */
+    for (size_t i = 0; i < N; ++i) {
+        int base = 1000000 + (int)(i * 1237);
+        if (i % 997 == 0) {
+            int s = 2000 + (int)(i % 500);
+            base = s * s;
+        }
+        big[i] = base;
+    }
+
+    racineCarreeTab(big, res, N);
+    printf("res (debut 10) = [");
+    for (size_t i = 0; i < 10 && i < N; ++i) {
+        if (i) printf(",");
+        printf("%d", res[i]);
+    }
+    if (N > 10) printf(", ...]");
+    printf("\n");
+
+    printf("\n EX3 : tests TriSpecial\n");
+    {
+        int a1[] = {3,5,25,16};
+        long long out1[4];
+        TriSpecial(a1, 4, out1);
+        affichageTabLL("TriSpecial([3,5,25,16]) = ", out1, 4);
+    }
+    {
+        int a2[] = {36,9,100,2,3,7};
+        long long out2[6];
+        TriSpecial(a2, 6, out2);
+        affichageTabLL("TriSpecial([36,9,100,2,3,7]) = ", out2, 6);
+    }
+
+    /* On utilise un gros tableau comme demandéé dans l'exo4 */
+    printf("\nEX4 : gros tableau (TriSpecial)\n");
+    /*la sortie pour le long tableau de gros elements*/
+    long long *sortieLL = (long long*)malloc(sizeof(long long) * N);
+    if (!sortieLL) {
+        fprintf(stderr, "Allocation echouee pour EX4 (sortieLL)\n");
+        free(big); free(res);
+        return 1;
+    }
+
+    TriSpecial(big, N, sortieLL);
+    /*Je me suis dit que 10 elements suffisait pour voir si on a le resultat attendu donc j'en affiche que 10*/
+    printf("TriSpecial(big) (debut 10) = [");
+    for (size_t i = 0; i < 10 && i < N; ++i) {
+        if (i) printf(",");
+        printf("%lld", sortieLL[i]);
+    }
+    if (N > 10) printf(", ...]");
+    printf("\n");
+
+    /* Nettoyage */
+    free(sortieLL);
+    free(big);
+    free(res);
+
+    return 0;
+}

reponses.txt

@@ -0,0 +1,91 @@
+
+
+    ----------------------------------------EX2---------------------------------------
+1-
+
+racineCarree : Temps : 0.09s et on a 10 008 appels. Ca fait donc un temps moyen d'appel de 0.01ms
+
+racineCarreeTab : avec grpof on nous dit que son temps d'execution est de 0s. On a 3 appels qui correspondent aux deux petits tableaux de test que j'ai dans mon main et au tableau
+avec 10 000 elements tous plus grand que 1 000 000. Si son temps d'execution est aussi cours c'est parce qu'on appelle racineCarree. Si on prend cela en compte on voit que 
+racineCarreeTab s'execute sur 30s environ.
+
+On a donc racineCarreeTab qui appel 10 006 fois racineCarree et les 2 autres sont dans le main avec les deux petits test que j'ai mis.
+
+Pour resume on a racineCarreeTab qui ne consomme presque rien car tout est delegue a racineCareeTab qui est appele en boucle pour parcourir le tableau.
+
+
+
+
+2-
+Complexite cyclomatioque :
+
+de racineCarree est de 5 car :
+1 "if (n < 0)"
+
+2 "if (n == 0 || n == 1) "
+
+3 "while (i <= n / i)"
+
+4 "if ((n % i == 0) && (i == n / i))"
+
+de racineCareeTab est de 2 car on a que la boucle for :
+La boucle "for (k = 0; k < size; ++k)"
+
+
+Complexite Algorithmique :
+
+---------de racineCarree : O(√n)-------------
+Si n n’est pas un carré parfait : on ne retourne pas avant la fin. Donc la boucle fait exactement ⌊√n⌋ itérations, puis on sort et on renvoie -1
+
+Si n est un carré parfait : on retourne à i = √n donc la boucle fait √n itérations (la dernière est celle qui trouve la racine)
+
+Dans tous les cas, le nombre d’itérations est proportionnel à √n
+
+-------- de racineCarreeTab dépend ----------
+
+du nombre d’éléments dans le tableau qu'on note m
+
+du temps d’exécution de racineCarree() pour chaque élément
+
+Et Puisque racineCarreeTab appelle racineCarree() m fois (une fois par élément du tableau) le coût total est la somme des coûts de chaque appel :
+
+On va regarder le pire, c'est celui ou tous les elements du tableau sont proche de l'element le plus grand. Par exemple dans notre exemple avec des valeurs > 1 000 000.
+On peut dire que toutes les valeurs sont proches de la plus grandes car a cette echelle de grandeur la difference est minim. On peut donc dire que dans le pire des cas
+la complexite est dependante du max (la plus grande valeurs) et du nombre d'appels a la fonction racineCarree
+on a comme complexite : O(m * √max)
+
+
+
+----------------------------EX4--------------------------------
+La complexite cyclomatique de TriSpecial :
+
+1 : if (!in || !out || n == 0)
+
+2 : if (!roots)
+
+3 : for (...) (branche !roots)
+
+4 : if (r == -1) (branche !roots)
+
+5 : for (...) (branche else)
+
+6 : if (r == -1) (branche else)
+
+7 : if (pair)
+
+8 : for (...) (branche pair)
+
+9 : if (i % 2 == 0) (branche pair)
+
+10 : for (...) (branche impair)
+
+11 : if (i % 2 == 0) (branche impair)
+
+Donc on a une complexite de 12 pour TriSpecial
+
+La complexite cyclomatique de TriSpecial : 
+
+C'est le meme principe que racineCarreeTab et ca depend du nombre d'appel et de l'element le plus grand
+
+On a O(N * √M) ou est M est le plus grand nombre et N le nombre d'appel.
+