1 to 5 clean

tp1/tp1_nb_secret.c

+#include <stdio.h>      /* printf(), scanf() */
+#include <stdlib.h>     /* srand(), rand() */
+#include <time.h>       /* time() */
+#include <math.h>       /* log() */
+
+void main(){
+    srand(time(NULL));
+
+    int max=0;
+    printf("enter max val ");
+    scanf("%d", &max);
+    
+    int prop;
+    int nb_rand = rand()%(max+1);
+    int nb_prop=1;
+    printf("try ? ");
+    scanf("%d",&prop);
+    int optimal=1;
+    
+
+    while(prop!=nb_rand){
+        
+        if(prop>max||prop<0){
+            printf("[0, %d] ! ",max);
+        }
+        else if(prop <nb_rand){
+            nb_prop++;
+            printf("higher ");
+        }
+        else if(prop >nb_rand){
+            nb_prop++;
+            printf("lower ");
+        }
+        printf("try again ");
+        scanf("%d",&prop);
+
+    }
+    while(max>1){
+        max/=2;
+        optimal++;
+    }
+       
+    printf("you found %d with %d try \n",nb_rand, nb_prop);
+    printf("optimal plays %d\n", optimal);
+
+
+
+
+}
\ No newline at end of file

tp2/bissection.c

+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include <stdbool.h>
+
+double Image(double x){
+    return pow(x,4)+pow(x,3)+pow(x,2)-1;
+}
+
+bool checkInterval(double a,double b){
+    //printf("%lf %lf \n",a,b);
+    return Image(a)*Image(b)>0;
+}
+
+bool checkPrecision(double e){
+    return e>pow(10,-9);
+}
+
+int bissect(double a, double b, double e, double *z){
+
+
+    double c;
+    int i=0;
+    while((b-a)>e){
+        i++;
+        printf("i : %d \n",i);
+        c=(a+b)/2;
+            if(Image(a)*Image(c)>0){ //sign(a)==sign(c)
+                a=c;
+            }else{
+                b=c;
+            }
+    printf("a %lf, b%lf c%lf",a,b,c);
+    }
+    //printf("interval : [%lf %lf] \n",a,b);
+    *z=(a+b)/2;
+   // printf("closest value: %lf which is : %lf\n",z,Image(z));
+    
+    return i;
+}
+
+
+int main(){
+
+
+double a;
+double b;
+double e;
+double zero1;
+
+    printf("enter interval ex : 2 10\n");
+    scanf("%lf %lf",&a,&b);
+    if(checkInterval(a,b)){
+        printf("enter precision ex: 0.0001\n");
+        scanf("%lf",&e);
+        if(checkPrecision(e)){
+
+            
+            int i=bissect(a,b,e,&zero1);
+            printf("zero: %lf with %d itterations\n",zero1,i);
+    
+
+        }else{
+
+        printf("precisision is too big ? \n");
+        }
+        
+    }else{
+
+    printf("wrong iterval \n");
+    }
+    
+return EXIT_SUCCESS;
+
+    
+}
\ No newline at end of file

tp3/Makefile

+
+frac: frac.o main.o
+	gcc frac.o main.o -o frac.x -lm
+
+frac.o: frac.c frac.h
+	gcc -Wall -Wextra -c frac.c
+
+main.o: main.c
+	gcc -Wall -Wextra -c main.c
+
+clean:
+	rm -f *.o frac
+
+rebuild: clean frac
\ No newline at end of file

tp3/frac.c

+#include "frac.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+ void frac_init(frac_t *a, int no, int de){
+
+    a->n=no;
+    a->d=de;
+     if(de==0){
+         printf("denominator can't be 0, set to 1\n");
+         a->d=1;
+     }
+
+ }
+
+void printFrac(frac_t a){
+    printf("%d/%d\n",a.n,a.d);
+}
+
+int PGCD(int a,int b){
+
+ //int n=a;
+ //int m=b;
+// if(a<b){
+//     int tmp1=a;
+//     a=b;
+//     b=tmp1;
+// }
+
+
+   while (a%b > 0) {
+      int tmp = a;
+      a = b;
+      b = tmp%b;
+   }
+    // printf("Le pgcd de %d et %d est %d \n",n,m,b);
+  
+  return b;
+
+}
+
+void reduc(frac_t *a){
+   // printf("avant reduc %d/%d\n",a->n,a->d);
+    int div=PGCD(a->n,a->d);
+    a->n/=div;
+    a->d/=div;
+   // printf("apres reduc %d/%d\n",a->n,a->d);
+
+ }
+
+
+
+frac_t powFrac(frac_t a,int p){
+
+    a.n=pow(a.n,p);
+    a.d=pow(a.d,p);
+
+    return a;
+}
+
+void add(frac_t *a, frac_t b){
+
+frac_t c;
+ frac_init(&c,a->n,a->d);
+
+    //a
+    a->n*=b.d;
+    a->d*=b.d;
+
+    //b
+    b.n*=c.d;
+    b.d*=c.d;
+    a->n+=b.n;
+    //a->d+=b.d; deno is the same
+
+    reduc(a);
+
+}
+
+frac_t sub(frac_t a, frac_t b){
+   
+    a.n*=b.d;
+    a.d*=b.d;
+
+    b.n*=a.d;
+    b.d*=a.d;
+
+    a.n-=b.n;
+    a.d-=b.d;
+
+    reduc(&a);
+    return a;
+}
+
+frac_t mult(frac_t a, frac_t b){
+    a.n*=b.n;
+    a.d*=b.d;
+
+    reduc(&a);
+    return a;
+}
+
+frac_t divFrac(frac_t a, frac_t b){
+    a.n*=b.d;
+    a.d*=b.n;
+
+    reduc(&a);
+    return a;
+}
+
+frac_t neg(frac_t a){
+
+    a.n*=-1;
+    return a;
+}
+
+double toDouble(frac_t a){
+    return a.n/a.d;
+}
+
+
+

tp3/frac.h

+#ifndef _FRAC_H_
+#define _FRAC_H_
+
+typedef struct fraction {
+    int n;
+    int d;
+    }
+ frac_t;
+
+void frac_init(frac_t *a, int no, int de);
+
+void printFrac(frac_t a);
+
+int PGCD(int a,int b);
+
+void reduc(frac_t *a);
+
+frac_t powFrac(frac_t a,int p);
+
+void add(frac_t *a, frac_t b);
+
+frac_t sub(frac_t a, frac_t b);
+
+frac_t mult(frac_t a, frac_t b);
+
+frac_t divFrac(frac_t a, frac_t b);
+
+frac_t neg(frac_t a);
+
+double toDouble(frac_t a);
+
+#endif

tp3/main.c

+
+#include "frac.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+
+  frac_t f1;
+  frac_t f2;
+  int n1, n2, d1, d2;
+
+  printf("1 enter a fraction : n d\n");
+  scanf("%d %d", &n1, &d1);
+  frac_init(&f1, n1, d1);
+  printFrac(f1);
+
+  printf("2 enter a fraction : n d\n");
+  scanf("%d %d", &n2, &d2);
+  frac_init(&f2, n2, d2);
+
+  printFrac(f2);
+
+  add(&f1, f2);
+  printf("f1+f2= ");
+   printFrac(f1);
+
+  // //frac_init(&f1,1,2);
+
+  // frac_t f1;
+  // frac_init(&f1,1,2);
+
+  //     frac_t f;
+  //     frac_t sum;
+  //     frac_init(&sum,1,1);
+
+  //     //double sum=0;
+
+  //      for(int i=2;i<5;i++){
+
+  //          frac_init(&f,1,pow(i,4));
+  //          add(&sum,f);
+
+  //      }
+  //      printf("result : %f",toDouble(sum));
+  //        // sum+=toDouble(f);
+  //    // print(f1);
+
+  return 0;
+}
\ No newline at end of file

tp4/Makefile

+
+
+
+CC=gcc -Wall -Wextra -g -fsanitize=leak -fsanitize=undefined -fsanitize=address
+LIBS=-lSDL2
+
+arr1D.x: main.o arr1D.o gfx.o
+	$(CC) $^ -o $@ $(LIBS)
+
+main.o: main.c
+	$(CC) -c $< $(LIBS)
+
+arr1D.o: arr1D.c arr1D.h
+	$(CC) -c $< $(LIBS)
+
+gfx.o: gfx.c gfx.h
+	$(CC) -c $< $(LIBS)
+
+clean:
+	@rm -f *.o arr1D.x
+
+
+
+
+# arr1D: arr1D.o main.o gfx.o 
+# 	gcc arr1D.o main.o gfx.o -o arr1D.x -lm -LSDL2
+
+
+# arr1D.o: arr1D.c arr1D.h 
+# 	gcc -Wall -Wextra -c arr1D.c
+
+# gfx.o: gfx.h gfx.c
+# 	gcc -Wall -Wextra -c gfx.c 
+
+
+# main.o: main.c
+# 	gcc -Wall -Wextra -c main.c
+
+# clean:
+# 	rm -f *.o arr1D
+
+# rebuild: clean arr1D
+
+
+# arr1D: arr1D.o main.o
+# 	gcc arr1D.o main.o -o arr1D -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+# arr1D.o: arr1D.c arr1D.h
+# 	gcc -Wall -Wextra -c arr1D.c -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+# main.o: main.c 
+# 	gcc -Wall -Wextra -c main.c -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+
+# clean: 
+# 	@rm -f *.o arr1D 
+
+# rebuild: clean arr1D
\ No newline at end of file

tp4/arr1D.c

+#include "arr1D.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void randomFill(int size, int arr[]) {
+  srand(time(NULL));
+
+  for (int i = 0; i < size; ++i) {
+
+    arr[i] = rand() % (size);
+  }
+}
+
+void printArr(int size, int arr[]) {
+
+  for (int i = 0; i < size; ++i) {
+
+    printf("[%d]= %d \n", i, arr[i]);
+  }
+}
+
+int findSmallest(int size, int arr[]) {
+
+  int s = arr[0];
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] < s) {
+      s = arr[i];
+    }
+  }
+  printf("smallest : %d\n", s);
+  return s;
+}
+
+int findBigest(int size, int arr[]) {
+
+  int s = arr[0];
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] > s) {
+      s = arr[i];
+    }
+  }
+  return s;
+}
+
+void checkEquity(int size, int arr[]) {
+
+  // printArr(size, arr);
+
+  int max = findBigest(size, arr)+1;
+  int histo[max];
+
+  for (int i = 0; i < max; ++i) {
+    histo[i] = 0;
+  }
+
+  // count each
+  for (int i = 0; i < size; ++i) {
+
+    histo[arr[i]]++;
+
+  }
+
+  for (int i = 0; i < max; i++) {
+    printf("nb de [%d]= %d \n", i, histo[i]);
+  }
+  // even if average=size/2
+}
+
+void histo(int size, int arr[], int histo[]) {
+
+  // count each
+  for (int i = 0; i < size - 1; ++i) {
+    histo[arr[i]]++;
+  }
+}
+
+void swapArr(int arr[], int i, int j) {
+  int tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+
+void bigToEnd(int size, int arr[]) {
+
+  int b = arr[0];
+  int index = 0;
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] > b) {
+      b = arr[i];
+      index = i;
+    }
+  }
+
+  swapArr(arr, index, size);
+}
+
+int seekElement(int size, int arr[], int el) {
+
+  int r = -1;
+  for (int i = 0; i < size; ++i) {
+
+    if (arr[i] == el) {
+      r = i;
+      break;
+    }
+  }
+
+  if (r == -1) {
+    printf("%d is not in the array", el);
+  } else {
+
+    printf("%d is at index %d\n", el, r);
+  }
+  return r;
+}
+
+double average(int size, int arr[]) {
+
+  double sum = 0.0;
+
+  for (int i = 0; i < size; ++i) {
+    sum += arr[i];
+  }
+  printf("average : %f\n", sum / size);
+  return sum / size;
+}
+
+double variance(int size, int arr[]) {
+
+  double m = average(size, arr);
+  double v = 0;
+  for (int i = 0; i < size; ++i) {
+    v += (arr[i] - m) * (arr[i] - m);
+  }
+  printf("variance= %f\n",v/size);
+  return v / size;
+}
+
+void sort(int size, int arr[]) {
+
+  int i_min;
+
+  for (int i = 1; i < size; i++) {
+    i_min = i;
+
+    for (int k = i + 1; k < size; k++) {
+      if (arr[k] < arr[i_min]) {
+        i_min = k;
+      }
+    }
+    swapArr(arr, i, i_min);
+  }
+}
+
+double findMedian(int size, int arr[]) {
+
+  sort(size, arr);
+
+  if (size % 2) { // odd
+    return arr[(size - 1) / 2];
+
+  } else { // even
+    return (arr[(size - 1) / 2] + arr[size / 2]) / 2.0;
+  }
+}

tp4/arr1D.h

+#ifndef _ARR1D_H_
+#define _ARR1D_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+void histo(int size, int arr[],int histo[]);
+
+void randomFill(int size, int arr[]);
+
+void printArr(int size, int arr[]);
+
+ int findSmallest(int size, int arr[]);
+
+  int findBigest(int size, int arr[]);
+
+
+ void checkEquity(int size, int arr[]);
+
+
+  void swapArr(int arr[],int i,int j);
+
+
+void bigToEnd(int size, int arr[]);
+
+
+ int seekElement(int size, int arr[],int el);
+
+ double average(int size,int arr[]);
+ 
+
+ double variance(int size,int arr[]);
+
+ void sort(int size,int arr[]);
+
+
+ double findMedian(int size,int arr[]);
+
+ 
+
+#endif

tp4/gfx.c

+/// @file gfx.c
+/// @author Florent Gluck
+/// @date November 6, 2016
+/// Helper routines to render pixels in fullscreen graphic mode.
+/// Uses the SDL2 library.
+
+#include "gfx.h"
+
+/// Create a fullscreen graphic window.
+/// @param title Title of the window.
+/// @param width Width of the window in pixels.
+/// @param height Height of the window in pixels.
+/// @return a pointer to the graphic context or NULL if it failed.
+struct gfx_context_t* gfx_create(char *title, uint width, uint height) {
+	if (SDL_Init(SDL_INIT_VIDEO) != 0) goto error;
+	SDL_Window *window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_RESIZABLE);
+	SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
+	SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
+			SDL_TEXTUREACCESS_STREAMING, width, height);
+	uint32_t *pixels = malloc(width*height*sizeof(uint32_t));
+	struct gfx_context_t *ctxt = malloc(sizeof(struct gfx_context_t));
+
+	if (!window || !renderer || !texture || !pixels || !ctxt) goto error;
+
+	ctxt->renderer = renderer;
+	ctxt->texture = texture;
+	ctxt->window = window;
+	ctxt->width = width;
+	ctxt->height = height;
+	ctxt->pixels = pixels;
+
+	SDL_ShowCursor(SDL_DISABLE);
+	gfx_clear(ctxt, COLOR_BLACK);
+	return ctxt;
+
+error:
+	return NULL;
+}
+
+/// Draw a pixel in the specified graphic context.
+/// @param ctxt Graphic context where the pixel is to be drawn.
+/// @param x X coordinate of the pixel.
+/// @param y Y coordinate of the pixel.
+/// @param color Color of the pixel.
+void gfx_putpixel(struct gfx_context_t *ctxt, int x, int y, uint32_t color) {
+	if (x < ctxt->width && y < ctxt->height)
+		ctxt->pixels[ctxt->width*y+x] = color;
+}
+
+/// Clear the specified graphic context.
+/// @param ctxt Graphic context to clear.
+/// @param color Color to use.
+void gfx_clear(struct gfx_context_t *ctxt, uint32_t color) {
+	int n = ctxt->width*ctxt->height;
+	while (n)
+		ctxt->pixels[--n] = color;
+}
+
+/// Display the graphic context.
+/// @param ctxt Graphic context to clear.
+void gfx_present(struct gfx_context_t *ctxt) {
+	SDL_UpdateTexture(ctxt->texture, NULL, ctxt->pixels, ctxt->width*sizeof(uint32_t));
+	SDL_RenderCopy(ctxt->renderer, ctxt->texture, NULL, NULL);
+	SDL_RenderPresent(ctxt->renderer);
+}
+
+/// Destroy a graphic window.
+/// @param ctxt Graphic context of the window to close.
+void gfx_destroy(struct gfx_context_t *ctxt) {
+	SDL_ShowCursor(SDL_ENABLE);
+	SDL_DestroyTexture(ctxt->texture);
+	SDL_DestroyRenderer(ctxt->renderer);
+	SDL_DestroyWindow(ctxt->window);
+	free(ctxt->pixels);
+	ctxt->texture = NULL;
+	ctxt->renderer = NULL;
+	ctxt->window = NULL;
+	ctxt->pixels = NULL;
+	SDL_Quit();
+	free(ctxt);
+}
+
+/// If a key was pressed, returns its key code (non blocking call).
+/// List of key codes: https://wiki.libsdl.org/SDL_Keycode
+/// @return the key that was pressed or 0 if none was pressed.
+SDL_Keycode gfx_keypressed() {
+	SDL_Event event;
+	if (SDL_PollEvent(&event)) {
+		if (event.type == SDL_KEYDOWN)
+			return event.key.keysym.sym;
+	}
+	return 0;
+}
+

tp4/gfx.h

+#ifndef _GFX_H_
+#define _GFX_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+
+#define MAKE_COLOR(r,g,b) ((uint32_t)b|((uint32_t)g<<8)|((uint32_t)r<<16))
+
+#define COLOR_GET_B(color) (color & 0xff)
+#define COLOR_GET_G(color) ((color >> 8) & 0xff)
+#define COLOR_GET_R(color) ((color >> 16) & 0xff)
+
+#define COLOR_BLACK  0x00000000
+#define COLOR_RED    0x00FF0000
+#define COLOR_GREEN  0x0000FF00
+#define COLOR_BLUE   0x000000FF
+#define COLOR_WHITE  0x00FFFFFF
+#define COLOR_YELLOW 0x00FFFF00
+
+typedef unsigned int  uint;
+typedef unsigned long ulong;
+typedef unsigned char uchar;
+
+struct gfx_context_t {
+	SDL_Window *window;
+	SDL_Renderer *renderer;
+	SDL_Texture *texture;
+	uint32_t *pixels;
+	int width;
+	int height;
+};
+
+extern void gfx_putpixel(struct gfx_context_t *ctxt, int x, int y, uint32_t color);
+extern void gfx_clear(struct gfx_context_t *ctxt, uint32_t color);
+extern struct gfx_context_t* gfx_create(char *text, uint width, uint height);
+extern void gfx_destroy(struct gfx_context_t *ctxt);
+extern void gfx_present(struct gfx_context_t *ctxt);
+extern SDL_Keycode gfx_keypressed();
+
+#endif

tp4/main.c

+
+#include "arr1D.h"
+#include "gfx.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void render(struct gfx_context_t *context, int tab[], int size) {
+  gfx_clear(context, COLOR_BLACK);
+
+  uint32_t intensity = 255;
+  uint32_t color = MAKE_COLOR(intensity, intensity, intensity);
+  for (int i = 0; i < size; i++) {
+    for (int j = 0; j < tab[i]; j++) {
+      gfx_putpixel(context, i + 10, j, color);
+    }
+  }
+}
+
+int main() {
+  // 1
+  printf("enter size\n");
+  int size;
+  scanf("%d", &size);
+  // 2
+  int arr[size];
+  randomFill(size, arr);
+  printArr(size, arr);
+  // 3
+  findSmallest(size, arr);
+  // 4
+  //bigToEnd(size, arr);
+  printArr(size, arr);
+  // 5
+  printf("enter element to seek\n");
+  int el;
+  scanf("%d", &el);
+  seekElement(size, arr, el);
+  //6
+   average(size, arr);
+   //7
+   variance(size, arr);
+   //8
+   sort(size, arr);
+   printArr(size,arr);
+   //9
+   printf("median= %f\n",findMedian(size,arr));
+   //11
+  checkEquity(size, arr);
+ //12
+  int counter[size + 1];
+
+  for (int i = 0; i < size+1; ++i) {
+    counter[i] = 0;
+  }
+
+  histo(size, arr, counter);
+  printArr(size, counter);
+
+  int width = 800, height = 600;
+  struct gfx_context_t *ctxt = gfx_create("Example", width, height);
+  if (!ctxt) {
+    fprintf(stderr, "Graphics initialization failed!\n");
+    return EXIT_FAILURE;
+  }
+
+  while (gfx_keypressed() != SDLK_ESCAPE) {
+    render(ctxt, counter, size);
+    gfx_present(ctxt);
+  }
+
+  gfx_destroy(ctxt);
+  return EXIT_SUCCESS;
+}

tp5/frac/Makefile

+
+frac: frac.o main.o
+	gcc frac.o main.o -o frac.x -lm -g -fsanitize=address -fsanitize=leak
+
+frac.o: frac.c frac.h
+	gcc -Wall -Wextra -c frac.c -g -fsanitize=address -fsanitize=leak
+
+main.o: main.c
+	gcc -Wall -Wextra -c main.c -g -fsanitize=address -fsanitize=leak
+
+clean:
+	rm -f *.o frac
+
+rebuild: clean frac
\ No newline at end of file

tp5/frac/frac.c

+#include "frac.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+frac_t *frac_init(int no, int de) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  // printf("%ld \n\n\n\n\n",sizeof(frac_t));
+
+  f->n = no;
+  if (de == 0) {
+    printf("denominator can't be 0, set to 1 \n");
+    f->d = 1;
+  } else {
+    f->d = de;
+  }
+
+  return f;
+}
+
+void clearFrac(frac_t *address) { free(address); }
+
+void printFrac(frac_t *a) { printf("%d/%d \n", a->n, a->d); }
+
+int PGCD(int a, int b) {
+
+  // int n=a;
+  // int m=b;
+
+  while (a % b > 0) {
+    int tmp = a;
+    a = b;
+    b = tmp % b;
+  }
+  //  printf("Le pgcd de %d et %d est %d \n",n,m,b);
+
+  return b;
+}
+
+void reduc(frac_t *a) {
+
+  int div = PGCD(a->n, a->d);
+  a->n /= div;
+  a->d /= div;
+}
+
+frac_t *powFrac(frac_t *a, int p) {
+
+  a->n = pow(a->n, p);
+  a->d = pow(a->d, p);
+
+  return a;
+}
+
+frac_t *add(frac_t *a, frac_t *b) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  f->n = a->n * b->d + b->n * a->d;
+  f->d = a->d * b->d;
+
+  // printf("before reduc %d %d",f->n,f->d);
+  reduc(f);
+  // printf("after reduc %d %d",f->n,f->d);
+  return f;
+}
+
+frac_t *sub(frac_t *a, frac_t *b) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  f->n = a->n * b->d - b->n * a->d;
+
+  f->d = a->d * b->d;
+  // printf("before reduc %d %d\n",f->n,f->d);
+  reduc(f);
+
+  return f;
+}
+
+frac_t *mult(frac_t *a, frac_t *b) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  f->n = a->n * b->n;
+  f->d = a->d * b->d;
+
+  reduc(f);
+  return f;
+}
+
+frac_t *divFrac(frac_t *a, frac_t *b) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  f->n = a->n * b->d;
+  f->d = a->d * b->n;
+
+  reduc(f);
+  return f;
+}
+
+// frac_t neg(frac_t a){
+
+//     a.n*=-1;
+//     return a;
+// }
+
+double *toDouble(frac_t *a) {
+  double *dbl = malloc(sizeof(double));
+
+  *dbl = a->n / (a->d * 1.0);
+  printf("%f\n", *dbl);
+  return dbl;
+}
+
+void add2(frac_t *a, frac_t *b) {
+
+  frac_t *f = malloc(sizeof(frac_t));
+
+  f->n = a->n * b->d + b->n * a->d;
+
+  f->d = a->d * b->d;
+
+  a->n = f->n;
+  a->d = f->d;
+
+  free(f);
+  // printf("before reduc %d %d",f->n,f->d);
+  // reduc(f);
+  // printf("after reduc %d %d",f->n,f->d);
+}
+
+void PI() {
+  frac_t *pi = frac_init(1, 1);
+  frac_t *f;
+
+  for (int i = 2; i < 6; i++) {
+
+    f = frac_init(1, pow(i, 4));
+    frac_t *tmp=add(pi, f);
+    pi->n=tmp->n;
+    pi->d=tmp->d;
+    clearFrac(tmp);
+    clearFrac(f);
+    
+  }
+    printFrac(pi);
+
+
+  clearFrac(pi);
+  // clearFrac(f);
+}

tp5/frac/frac.h

+#ifndef _FRAC_H_
+#define _FRAC_H_
+
+typedef struct fraction {
+    int n;
+    int d;
+    }
+ frac_t;
+
+frac_t *frac_init(int no, int de);
+
+void clearFrac(frac_t *address);
+
+void printFrac(frac_t *a);
+
+frac_t *add(frac_t *a, frac_t *b);
+
+frac_t *sub(frac_t *a, frac_t *b);
+
+ frac_t *mult(frac_t *a, frac_t *b);
+
+frac_t *divFrac(frac_t *a, frac_t *b);
+
+void PI();
+
+int PGCD(int a,int b);
+
+// void reduc(frac_t *a);
+
+frac_t *powFrac(frac_t *a,int p);
+
+
+
+// frac_t neg(frac_t a);
+
+double *toDouble(frac_t *a);
+
+#endif

tp5/frac/main.c

+#include "frac.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char *argv[]) {
+
+  if (argc == 2) {
+    if (!strcmp(argv[1], "PI")) {
+      PI();
+      }
+      
+    } else if (argc == 4) {
+      if (!strcmp(argv[3], "PGCD")) {
+        printf("PGCD : %d\n", PGCD(atoi(argv[1]), atoi(argv[2])));
+      }
+
+
+    } else if (argc == 5) {
+      frac_t *f1 = frac_init(atoi(argv[1]), atoi(argv[2]));
+
+      if (*argv[3] == '^') {
+        printFrac(f1);
+        frac_t *f3 = powFrac(f1, atoi(argv[4]));
+        printFrac(f3);
+        clearFrac(f3);
+      }
+
+
+    } else if (argc == 6) {
+
+      frac_t *f3;
+      frac_t *f1 = frac_init(atoi(argv[1]), atoi(argv[2]));
+      printFrac(f1);
+
+      frac_t *f2 = frac_init(atoi(argv[4]), atoi(argv[5]));
+      printFrac(f2);
+
+      // opperation
+      switch (*argv[3]) {
+
+      case '+':
+        f3 = add(f1, f2);
+        break;
+
+      case '-':
+        f3 = sub(f1, f2);
+        break;
+
+      case 'x':
+        f3 = mult(f1, f2);
+        break;
+
+      case '/':
+        f3 = divFrac(f1, f2);
+        break;
+      }
+      printFrac(f3);
+
+      double *d = toDouble(f3);
+      free(d);
+      clearFrac(f3);
+
+      clearFrac(f1);
+      clearFrac(f2);
+
+
+    } else {
+
+      printf(" nb of args : %d \nusage : 1 3 + 6 7 or 1 2 ^ 2\n", argc);
+
+      for (int i = 0; i < argc; i++) {
+        printf("arg[%d] = %s\n", i, argv[i]);
+      }
+      return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+  }
\ No newline at end of file

tp5/tab/Makefile

+
+
+
+CC=gcc -Wall -Wextra -g -fsanitize=leak -fsanitize=undefined -fsanitize=address
+LIBS=-lSDL2
+
+arr1D.x: main.o arr1D.o gfx.o
+	$(CC) $^ -o $@ $(LIBS)
+
+main.o: main.c
+	$(CC) -c $< $(LIBS)
+
+arr1D.o: arr1D.c arr1D.h
+	$(CC) -c $< $(LIBS)
+
+gfx.o: gfx.c gfx.h
+	$(CC) -c $< $(LIBS)
+
+clean:
+	@rm -f *.o arr1D.x
+
+
+
+
+# arr1D: arr1D.o main.o gfx.o 
+# 	gcc arr1D.o main.o gfx.o -o arr1D.x -lm -LSDL2
+
+
+# arr1D.o: arr1D.c arr1D.h 
+# 	gcc -Wall -Wextra -c arr1D.c
+
+# gfx.o: gfx.h gfx.c
+# 	gcc -Wall -Wextra -c gfx.c 
+
+
+# main.o: main.c
+# 	gcc -Wall -Wextra -c main.c
+
+# clean:
+# 	rm -f *.o arr1D
+
+# rebuild: clean arr1D
+
+
+# arr1D: arr1D.o main.o
+# 	gcc arr1D.o main.o -o arr1D -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+# arr1D.o: arr1D.c arr1D.h
+# 	gcc -Wall -Wextra -c arr1D.c -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+# main.o: main.c 
+# 	gcc -Wall -Wextra -c main.c -Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined  -fsanitize=address -LSDL2
+
+
+# clean: 
+# 	@rm -f *.o arr1D 
+
+# rebuild: clean arr1D
\ No newline at end of file

tp5/tab/arr1D.c

+#include "arr1D.h"
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void arr2d_init(int height, int width, int **histo_2d) {
+
+ *histo_2d= malloc(height * sizeof(int *));
+
+  for (int i = 0; i < height; i++) {
+    histo_2d[i] = malloc(width * sizeof(int));
+  }
+
+  for (int i = 0; i < height; i++) {
+    for (int j = 0; j < width; j++) {
+      histo_2d[i][j] = 0;
+    }
+  }
+}
+
+void randomFill2D(int height, int width, int **arr2d) {
+
+ 
+
+  
+  for (int i = 0; i < height*width; i++) {
+    int r1 = rand() % (height);
+    int r2 = rand() % (width);
+    arr2d[r1][r2]++;
+  }
+}
+
+void display2D(int height, int width, int **arr2d) {
+  for (int i = 0; i < height; i++) {
+    printf("\n");
+    for (int j = 0; j < width; j++) {
+      printf("%d ",arr2d[i][j]);
+    
+    }
+  }
+  printf("\n");
+}
+
+void randomFill(int size, int arr[]) {
+  srand(time(NULL));
+
+  for (int i = 0; i < size; ++i) {
+
+    arr[i] = rand() % (size);
+  }
+}
+
+void printArr(int size, int arr[]) {
+
+  for (int i = 0; i < size; ++i) {
+
+    printf("[%d]= %d \n", i, arr[i]);
+  }
+}
+
+int findSmallest(int size, int arr[]) {
+
+  int s = arr[0];
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] < s) {
+      s = arr[i];
+    }
+  }
+  printf("smallest : %d\n", s);
+  return s;
+}
+
+int findBigest(int size, int arr[]) {
+
+  int s = arr[0];
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] > s) {
+      s = arr[i];
+    }
+  }
+  return s;
+}
+
+void checkEquity(int size, int arr[]) {
+
+  // printArr(size, arr);
+
+  int max = findBigest(size, arr) + 1;
+  int histo[max];
+
+  for (int i = 0; i < max; ++i) {
+    histo[i] = 0;
+  }
+
+  // count each
+  for (int i = 0; i < size; ++i) {
+
+    histo[arr[i]]++;
+  }
+
+  for (int i = 0; i < max; i++) {
+    printf("nb de [%d]= %d \n", i, histo[i]);
+  }
+  // even if average=size/2
+}
+
+void histo(int size, int arr[], int histo[]) {
+
+  // count each
+  for (int i = 0; i < size - 1; ++i) {
+    histo[arr[i]]++;
+  }
+}
+
+void swapArr(int arr[], int i, int j) {
+  int tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+
+void bigToEnd(int size, int arr[]) {
+
+  int b = arr[0];
+  int index = 0;
+
+  for (int i = 1; i < size; ++i) {
+
+    if (arr[i] > b) {
+      b = arr[i];
+      index = i;
+    }
+  }
+
+  swapArr(arr, index, size);
+}
+
+int seekElement(int size, int arr[], int el) {
+
+  int r = -1;
+  for (int i = 0; i < size; ++i) {
+
+    if (arr[i] == el) {
+      r = i;
+      break;
+    }
+  }
+
+  if (r == -1) {
+    printf("%d is not in the array", el);
+  } else {
+
+    printf("%d is at index %d\n", el, r);
+  }
+  return r;
+}
+
+double average(int size, int arr[]) {
+
+  double sum = 0.0;
+
+  for (int i = 0; i < size; ++i) {
+    sum += arr[i];
+  }
+  printf("average : %f\n", sum / size);
+  return sum / size;
+}
+
+double variance(int size, int arr[]) {
+
+  double m = average(size, arr);
+  double v = 0;
+  for (int i = 0; i < size; ++i) {
+    v += (arr[i] - m) * (arr[i] - m);
+  }
+  printf("variance= %f\n", v / size);
+  return v / size;
+}
+
+void sort(int size, int arr[]) {
+
+  int i_min;
+
+  for (int i = 1; i < size; i++) {
+    i_min = i;
+
+    for (int k = i + 1; k < size; k++) {
+      if (arr[k] < arr[i_min]) {
+        i_min = k;
+      }
+    }
+    swapArr(arr, i, i_min);
+  }
+}
+
+double findMedian(int size, int arr[]) {
+
+  sort(size, arr);
+
+  if (size % 2) { // odd
+    return arr[(size - 1) / 2];
+
+  } else { // even
+    return (arr[(size - 1) / 2] + arr[size / 2]) / 2.0;
+  }
+}

tp5/tab/arr1D.h

+#ifndef _ARR1D_H_
+#define _ARR1D_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+void arr2d_init(int height, int width, int **histo_2d);
+
+void randomFill2D(int height, int width, int **arr2d);
+
+void display2D(int height, int width, int **arr2d);
+
+
+void histo(int size, int arr[],int histo[]);
+
+void randomFill(int size, int arr[]);
+
+void printArr(int size, int arr[]);
+
+ int findSmallest(int size, int arr[]);
+
+  int findBigest(int size, int arr[]);
+
+
+ void checkEquity(int size, int arr[]);
+
+
+  void swapArr(int arr[],int i,int j);
+
+
+void bigToEnd(int size, int arr[]);
+
+
+ int seekElement(int size, int arr[],int el);
+
+ double average(int size,int arr[]);
+ 
+
+ double variance(int size,int arr[]);
+
+ void sort(int size,int arr[]);
+
+
+ double findMedian(int size,int arr[]);
+
+ 
+
+#endif

tp5/tab/gfx.c

+/// @file gfx.c
+/// @author Florent Gluck
+/// @date November 6, 2016
+/// Helper routines to render pixels in fullscreen graphic mode.
+/// Uses the SDL2 library.
+
+#include "gfx.h"
+
+/// Create a fullscreen graphic window.
+/// @param title Title of the window.
+/// @param width Width of the window in pixels.
+/// @param height Height of the window in pixels.
+/// @return a pointer to the graphic context or NULL if it failed.
+struct gfx_context_t* gfx_create(char *title, uint width, uint height) {
+	if (SDL_Init(SDL_INIT_VIDEO) != 0) goto error;
+	SDL_Window *window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_RESIZABLE);
+	SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
+	SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
+			SDL_TEXTUREACCESS_STREAMING, width, height);
+	uint32_t *pixels = malloc(width*height*sizeof(uint32_t));
+	struct gfx_context_t *ctxt = malloc(sizeof(struct gfx_context_t));
+
+	if (!window || !renderer || !texture || !pixels || !ctxt) goto error;
+
+	ctxt->renderer = renderer;
+	ctxt->texture = texture;
+	ctxt->window = window;
+	ctxt->width = width;
+	ctxt->height = height;
+	ctxt->pixels = pixels;
+
+	SDL_ShowCursor(SDL_DISABLE);
+	gfx_clear(ctxt, COLOR_BLACK);
+	return ctxt;
+
+error:
+	return NULL;
+}
+
+/// Draw a pixel in the specified graphic context.
+/// @param ctxt Graphic context where the pixel is to be drawn.
+/// @param x X coordinate of the pixel.
+/// @param y Y coordinate of the pixel.
+/// @param color Color of the pixel.
+void gfx_putpixel(struct gfx_context_t *ctxt, int x, int y, uint32_t color) {
+	if (x < ctxt->width && y < ctxt->height)
+		ctxt->pixels[ctxt->width*y+x] = color;
+}
+
+/// Clear the specified graphic context.
+/// @param ctxt Graphic context to clear.
+/// @param color Color to use.
+void gfx_clear(struct gfx_context_t *ctxt, uint32_t color) {
+	int n = ctxt->width*ctxt->height;
+	while (n)
+		ctxt->pixels[--n] = color;
+}
+
+/// Display the graphic context.
+/// @param ctxt Graphic context to clear.
+void gfx_present(struct gfx_context_t *ctxt) {
+	SDL_UpdateTexture(ctxt->texture, NULL, ctxt->pixels, ctxt->width*sizeof(uint32_t));
+	SDL_RenderCopy(ctxt->renderer, ctxt->texture, NULL, NULL);
+	SDL_RenderPresent(ctxt->renderer);
+}
+
+/// Destroy a graphic window.
+/// @param ctxt Graphic context of the window to close.
+void gfx_destroy(struct gfx_context_t *ctxt) {
+	SDL_ShowCursor(SDL_ENABLE);
+	SDL_DestroyTexture(ctxt->texture);
+	SDL_DestroyRenderer(ctxt->renderer);
+	SDL_DestroyWindow(ctxt->window);
+	free(ctxt->pixels);
+	ctxt->texture = NULL;
+	ctxt->renderer = NULL;
+	ctxt->window = NULL;
+	ctxt->pixels = NULL;
+	SDL_Quit();
+	free(ctxt);
+}
+
+/// If a key was pressed, returns its key code (non blocking call).
+/// List of key codes: https://wiki.libsdl.org/SDL_Keycode
+/// @return the key that was pressed or 0 if none was pressed.
+SDL_Keycode gfx_keypressed() {
+	SDL_Event event;
+	if (SDL_PollEvent(&event)) {
+		if (event.type == SDL_KEYDOWN)
+			return event.key.keysym.sym;
+	}
+	return 0;
+}
+