Checkpoint

obligatoire/Cours/methodes numeriques.py

@@ -17,3 +17,13 @@ def dichotomie(f, a, b, epsilon=1e-15):
         else:
             g = m
     return (g+d)/m
+
+def newton(f, fp, x0, nbiter):
+    u1 = x0
+    u2 = u1 - f(u1)/fp(u1)
+    epsilon = 1e-8
+    for i in range(nbiter):
+        if abs(u1 - u2) < epsilon :
+            return (u2, f(u2), nbiter, u1 - u2)
+        u1, u2 = u2, u2 - f(u2)/fp(u2)
+    raise

obligatoire/TP5/main.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+def creerTableau(n):
+    return [0]*n
+
+#Premiere partie
+#1.
+
+def creerTabVide(n):
+    T=creerTableau(n+1)
+    for i in range(n+1):
+        T[i]=0
+    return T
+#2.
+def estDansTab(tab, x):
+    for el in tab[1:tab[0]+1]:
+        if el==x:
+            return True
+    return False
+"""
+Dans le pire cas, c'est à dire le cas ou l'élément recherché
+n'est pas dans le tableau, la boucle parcourera la totalité de la liste 
+et effectuera un test. Or il y a n éléments dans la liste, donc
+le test sera effectué n fois. Par conséquent, la complexité de la 
+fonction est O(n)
+"""
+
+#3.
+def ajouteDansTab(tab, x):
+    if not estDansTab(tab, x):
+        tab[tab[0] + 1] = x
+        tab[0]+=1
+"""
+Si la liste tab est pleine et que x n'est pas encore dans la liste initiale
+, la procédure renvoira une erreur car l'index maximal sera dépassé.
+
+Dans tous les cas, le tableau ne contiendra pas x.
+La procedure appellera d'abord estDansTab puis executera deux instructions.
+par conséquent, la complexité sera celle de estDansTab.
+La procédure a une complexité O(n)
+"""
+
+#Deuxième partie
+
+#1.
+plan1=[ [5, 7],
+       [2, 2, 3, 0, 0],
+       [3, 1, 3, 5, 0],
+       [4, 1, 2, 4, 5],
+       [2, 3, 5, 0, 0],
+       [3, 2, 3, 4, 0] ]
+plan2=[ [5, 4],
+       [1, 2, 0, 0, 0],
+       [3, 1, 3, 4, 0],
+       [1, 2, 0, 0, 0],
+       [2, 2, 5, 0, 0],
+       [1, 4, 0, 0, 0]]
+#2.
+def creerPlanSansRoute(n):
+    return [[n,0]]+[creerTabVide(n-1) for _ in range(n)]
+
+#3.
+def estVoisine(plan, x, y):
+    return estDansTab(plan[x], y)
+
+#4.
+def ajouteRoute(plan, x, y):
+    plan[0][1] += 1
+    ajouteDansTab(plan[x], y)
+    ajouteDansTab(plan[y], x)
+"""
+Il y a n villes dans le plan. donc chaque ville peut avoir, au plus
+n-1 voisines. Les tableaux représentant les voisines de chaque ville
+peuvent contenir au plus n-1 élément. Il n'y aura donc pas de dépassement."""
+
+#5.
+
+def afficheToutesLesRoutes(plan):
+    routes=[None]
+    for i in range(1,plan[0][0] + 1):
+        for voisine in plan[i][1:plan[i][0] + 1]:
+            for route in routes:
+                if route == {i, voisine}:
+                    break
+            if route is None:
+                routes.insert(0, {i, voisine})
+                    
+    print("["+", ".join([str(tuple(route)).replace(", ", " - ") for route in routes[:-1][::-1]])+"]")
+"""
+Dans le pire des cas, la fonction effectura :
+    n fois la suite d'opération qui consiste à effectuer:
+        n-1 fois la suite d'operation qui consiste à
+            boucler parmi les routes déjà trouvées.
+    ainsi, dans le pire des cas, la procédure aura une complexité
+    O(n(n-1)m = O (mn² - mn)' = O(mn²)
+        
+"""
+plan3=creerPlanSansRoute(11)
+ajouteRoutes = lambda plan, x : [ajouteRoute(plan, *route) for route in x]
+ajouteRoutes(plan3, [(1,6),(1,2),(2,7),(6,7),(6,5),(5,10),(10,11),(11,9),(9,8),(8,7),(8,3),(3,4),(8,4)])
+
+#Troisième partie
+
+
+

spe/TP0/main.ml

@@ -0,0 +1,15 @@
+(* exercice 1 *)
+let rec pgcd a b = match b with
+    | 0 -> a
+#    | _ -> pgcd (b) (a mod b);;
+
+print_int (pgcd 12 6);;
+
+(* exercice 2*)
+let rec dichotomie func a b epsilon = 
+    let c = (a+.b)/.2. in
+    if (b -. a) < epsilon then c 
+    else if func(c) *. func(b) > 0. then dichotomie func c b epsilon
+    else dichotomie func a c epsilon;;
+
+print_float (dichotomie sin 1. 4. 0.001);;

spe/TP1/main.ml

@@ -0,0 +1,41 @@
+(* Exercice 1 *)
+(*1)*)
+() ;;
+(*2)*)
+let c2() = 2;;
+(*3)*)
+let rien a = ();;
+(*4)*)
+let hello() = print_string "Hello World !\n";;
+
+(*Exercice 2*)
+
+let rec itere f n a = match n with
+	| 0 -> a
+	| _ -> f (itere f (n-1) a);;
+itere sin 3000 1.;;
+
+(* Exercice 3*)
+(*1) : La fonction List.length retourne la longueur d'une liste.*)
+let rec longueur liste = match liste with
+	| [] -> 0
+	| _ -> (longueur (List.tl liste)) + 1;;
+
+longueur [1;2;3];;
+(*2) : La fonction List.map applique une fonction à chaque élément d'une liste.*)
+let rec mapper f liste = match liste with
+	| [] -> []
+	| _ -> (f (List.hd liste))::(mapper f (List.tl liste));;
+
+mapper sin [1.;2.;3.];;
+(*3)*)
+
+
+let rec concatener listes = match longueur listes with
+	| 0 -> []
+	| 1 -> List.hd listes
+	| 2 -> (List.hd listes)@(List.hd (List.tl listes))
+	| _ -> concatener ([(List.hd listes)@(List.hd (List.tl listes))]@(List.tl (List.tl listes)));;
+concatener [[1;2;3];[2;1;3];[4;5;1;3];[1]];;
+concatener [];;
+List.concat [];;

spe/cours/cours1.ml

@@ -0,0 +1,5 @@
+(* let rec arbre n = match n with
+    | 0 -> ()
+    | _ -> print_string 
+*)
+[1;2;3];;