jj

Maths/tp/Bases2/tp1/exo1_numpy_généralités.py

@@ -2,6 +2,7 @@
 ###############################################
 
 import numpy as np
+from math import log, cos, sin
 
 # Tous les passages indiqués "TODO()" sont à remplacer par vos soins
 def TODO():
@@ -15,16 +16,12 @@ A = np.array([ -4, -32,  25, -15, -12, -23,   4,  -3, -17])
 print("A=",A)
 print("len(A)=",len(A))
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 print("Définition d'un array Numpy avec la fonction arange:")
 # 	np.arange(DEBUT,FIN,PAS)
 # Fonctionne comme 'range', mais on peut utiliser des nombres non entiers
-B = np.arange(0,1,0.05) #entre 0 et 1, par pas de 0.05
+B = np.arange(0,1,0.05)
 print("B=",B)
-print("len(B)=",len(B)) #longueur du tableau
+print("len(B)=",len(B))
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
 print("Définition d'un array Numpy avec la fonction linspace:")
 #	np.linspace(DEBUT,FIN,NOMBRE_DE_POINTS)
@@ -33,50 +30,36 @@ print("C=",C)
 print("len(C)=",len(C))
 # Remarque: linspace est généralement le choix le plus pertinent pour les graphiques (voir plus loin)
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
-
 ### MANIPULATIONS DE BASE : À VOUS !
 
 print("Affichez un tableau contenant la somme de B et C (élément par élément):")
-Z = np.array([B+C])
+print(B + C)
-print(Z)
 
 # Remarque : notez bien la différence de fonctionnement comparé aux listes Python!
 # Dans le cadre de Numpy, l'opérateur '+' reprend un sens mathématique d'addition.
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 print("Définissez un tableau D de 100 nombres (exactement) répartis uniformément de 1 (inclus) à 10 (inclus).")
 D = np.linspace(1,10,100)
 print("D=",D)
 print("len(D)=",len(D))
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 print("Définissez un tableau E de 100 nombres, contenant le LOGARITHME DÉCIMAL de chaque valeur contenue dans D.")
-E = np.log10(D) # a exactement le meme nombre de valeurs que D
+E = np.log10(D)
 print("E=",E)
 print("len(E)=",len(E))
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 print("Définissez un tableau F de 100 nombres, contenant la formule \"cos(x)+2*sin(x)\" appliquée à chaque élément du tableau D.")
-F = np.cos(D)+2*np.sin(D) # a exactement le meme nombre de valeurs que D
+F = np.vectorize(lambda x: cos(x)+2*sin(x))(D)
+F = np.cos(D) + 2 * np.sin(D)
 print("F=",F)
 print("len(F)=",len(F))
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 print("Trouvez la plus grande valeur contenue dans le tableau F:")
-print("max(F)=",max(F))
+print(np.max(F))
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
 print("Créez un tableau contenant la concaténation des tableaux A et B, sur une seule ligne:")
 print("A=",A)
 print("B=",B)
-G = np.concatenate((A,B))
+print(np.concatenate((A, B)))
-print("G=",G)
 # (internet autorisé, attention aux parenthèses!)
 

Maths/tp/Bases2/tp1/exo2_numpy_indexation.py

@@ -2,6 +2,7 @@
 ###############################################
 
 import numpy as np
+from math import sqrt
 
 # Tous les passages indiqués "TODO()" sont à remplacer par vos soins
 def TODO():
@@ -15,10 +16,6 @@ A = np.array([ -4, -32,  25, -15, -12, -23,   4,  -3, -17,  47, -40,  20,  11,
 print("A=",A)
 print("len(A)=",len(A)) 
 
-#B = np.array([ 4, 6, 8, 9, 2, 1, 19, 101, 115, 12, 112, 2059, 500, 13,
-#              15, 805, 6077, 6070, 303, 200, 80, 70, 60, 50, 40, 30, 25, 76, 77, 78]) 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 ### SLICING
 
 # Le slicing permet d'accéder à une sous-partie d'une liste ou d'un tuple 
@@ -31,48 +28,32 @@ print("len(A)=",len(A))
 print("======= Exemple de slicing : A[3:14:2] ")
 print(A[3:14:2])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 # Si PAS est omis, il vaut 1 (on prend les éléments de 1 en 1)
 print("Affichez tous les éléments de l'index 3 (inclus) à 14 (exclus).")
 print(A[3:14])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 # Si DEBUT est omis, il vaut 0 (on part depuis le début du tableau)
 print("Affichez 1 élément sur 2, depuis le début et jusqu'à l'index 12 INCLUS")
 print(A[:13:2])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 # Si FIN est omis, on va jusqu'au bout du tableau
 print("Affichez 1 élément sur 3, depuis l'index 4 (inclus) jusqu'à la fin.")
 print(A[4::3])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
-
 # Si DEBUT et/ou FIN sont négatifs, ils indiquent une position en partant
 # de la fin du tableau (-1 est le dernier élément, -2 l'avant-dernier, etc.)
 print("Affichez les 10 derniers éléments de A.")
-print(A[-10::])
+print(A[-10:])
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
-print("\nAffichez 1 élément sur 3, en partant du début, et en vous arrêtant 10 éléments avant la fin du tableau.")
+print("Affichez 1 élément sur 3, en partant du début, et en vous arrêtant 10 éléments avant la fin du tableau.")
-print(A[:-9:3])
+print(A[:-10:3])
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
 # Si PAS est négatif, on lit les éléments dans le sens inverse.
-print("\nAffichez le tableau A à l'envers, depuis son dernier élément jusqu'au premier.")
+print("Affichez le tableau A à l'envers, depuis son dernier élément jusqu'au premier.")
 print(A[::-1])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
+print("Affichez les 10 derniers éléments de A, à l'envers.")
-
+print(A[:-11:-1])
-print("\nAffichez les 10 derniers éléments de A, à l'envers.")
-print(A[:-10:-1])
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
 
 ### INDEXATION PAR UNE LISTE D'INDICES 		(uniquement en Numpy)
@@ -80,21 +61,15 @@ print(A[:-10:-1])
 # En Numpy, on peut utiliser une LISTE (ou un autre ARRAY) de nombres entiers positifs
 # indiquant tous les emplacements qu'on souhaite lire dans le tableau.
 
-print("\n======= Exemple d'indexation par une liste :")
+print("======= Exemple d'indexation par une liste :")
 print("A=",A)
 print("len(A)=",len(A)) 
 indices = [1,3,4,5,10]
 print(indices)
 print(A[indices])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
+print("Extrayez le sous-tableau de A donné par les indices qui sont un nombre au carré (0,1,4,9, etc.) :")
-
+print(A[[n*n for n in range(int(sqrt(len(A))))]])
-print("\nExtrayez le sous-tableau de A donné par les indices qui sont un nombre au carré (0,1,4,9, etc.) :")
-carree = [0,1,4,9,16,25]
-print(carree)
-print(A[carree])
-
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
 
 
 ### INDEXATION PAR UN MASQUE BINAIRE 		(uniquement en Numpy)
@@ -103,20 +78,17 @@ print(A[carree])
 # taille que A, mais contenant des booléens indiquant si chaque index doit être 
 # conservé (True) ou écarté (False)
 
-print("\n======= Exemple d'indexation par masque binaire:")
+print("======= Exemple d'indexation par masque binaire:")
 print("A=",A)
 print("len(A)=",len(A)) 
 test = A>0
 print(test)
 print(A[test])
 
-# exit()	# -------------- Supprimez cette ligne pour passer à la suite ------------------
+print("Créez un tableau B, de la même taille que A, dans lequel les nombres pairs sont conservés, mais les nombres impairs sont remplacés par des 0 :")
-
-print("\nCréez un tableau B, de la même taille que A, dans lequel les nombres pairs sont conservés, mais les nombres impairs sont remplacés par des 0 :")
 B = A.copy()
-test1 = B%2==0
+B[np.mod(B, 2) != 0] = 0
-test2 = abs(B)%2!=0
-B[test2] = 0
 print(B)
+#print(np.mod(B, where=test))
 # Indice : utilisez la fonction np.mod
 

Maths/tp/Bases2/tp1/figures.py

@@ -0,0 +1,24 @@
+import matplotlib.pyplot as plt
+from math import cos, sin, tau
+
+points = 10
+frequence = tau / points
+
+rosace = True
+
+plt.figure()
+X=[cos(n * frequence) for n in range(points + 1)]
+Y=[sin(n * frequence) for n in range(points + 1)]
+
+if rosace:
+	for i in range(points):
+		o = frequence 
+	n = ((points // 2) - 1) 
+	X.append(cos(n * frequence))
+	Y.append(sin(n * frequence))
+
+
+plt.plot(X,Y,color='blue')
+plt.axis('equal')
+plt.title('Cercle')
+plt.show()

Maths/tp/Bases2/tp1/plot.py

@@ -0,0 +1,17 @@
+import matplotlib.pyplot as plt
+from matplotlib import collections as mc
+
+plt.figure()
+
+lignes = [[(-1, 0.5), (0, 0)], [(0, -1), (0, 1)], [(0, 0), (1, 0)], [(-1, -2), (0, -1)], [(0, -1), (1, -2)]]
+lc = mc.LineCollection(lignes, color='red', linewidths=1)
+fig, ax = plt.subplots()
+for a, b in lignes:
+	ax.scatter(a[0], a[1], 100, color='red')
+	ax.scatter(b[0], b[1], 100, color='red')
+ax.add_collection(lc)
+plt.axis('equal')
+plt.title('Bonhomme')
+plt.grid()
+plt.show()
+

Maths/tp/Bases2/tp1/zigzag.py

@@ -0,0 +1,14 @@
+import matplotlib.pyplot as plt
+
+frequence = 14
+hauteur = 0.2
+
+n = frequence * 2 + 1
+
+plt.figure()
+X=[i/frequence for i in range(n)]
+Y=[hauteur if (i % 2) == 1 else 0 for i in range(n)]
+plt.plot(X,Y,color='blue')
+plt.axis('equal')
+plt.title('Zigzag')
+plt.show()

Maths/tp/Bases2/tp2/exo1_premier_graphe.py

@@ -0,0 +1,51 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import math
+
+# Tous les passages indiqués "TODO()" sont à remplacer par vos soins
+def TODO():
+	print("à vous!")
+	exit()
+	
+	
+#################################################################################################
+### EXERCICE 1 : premier exemple de graphe
+#################################################################################################
+
+
+print("(1) Définissez un array numpy `x` contenant 100 nombres, allant de -5 (inclus) à 5 (inclus)")
+x = np.linspace(-5,5,100)
+print(x)
+# VOCABULAIRE: On dit que `x` constitue une DISCRÉTISATION de l'intervalle [-5,5] en 100 nombres.
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(2) Construisez un array numpy `y`, de la même taille que `x`, contenant l'exponentielle de chaque valeur contenue dans `x`")
+y = np.exp(x)
+print(y)
+# (indice : utilisez les fonctions prédéfinies de Numpy.)
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(3) Affichez le graphe représentant `x` en abscisses et `y` en ordonnées.")
+plt.plot(x,y)
+
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(4) Rajoutez une grille de coordonnées.")
+plt.grid()
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(5) Rajoutez un label \"x\" sur l'axe des abscisses, et \"exp(x)\" sur l'axe des ordonnées")
+plt.xlabel("x")
+plt.xlabel("exp(x)")
+plt.show()
+
+# (indice : cherchez les méthodes de matplotlib permettant de rajouter des labels sur les axes)
+
+#################################################################################################
+# Félicitations, vous venez de construire votre premier graphe de fonction sous Matplotlib !
+
+

Maths/tp/Bases2/tp2/exo2_modelisation.py

@@ -0,0 +1,62 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import math
+
+# Tous les passages indiqués "TODO()" sont à remplacer par vos soins
+def TODO():
+	print("à vous!")
+	exit()
+
+
+#################################################################################################
+### EXERCICE 2 : rentabilité d'un fabricant de processeurs
+#################################################################################################
+
+print("(1) Définissez un array numpy `N` contenant les entiers de 1 à 5000")
+N = np.arange(1,5001)
+# N = np.linspace(1,5000,1)
+print(N)
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(2) Construisez un array numpy `PN`, de la même taille que `N`, donnant le coût de production en fonction du nombre d'unités fabriquées")
+
+PN = 2000 + 60 * (N)**(2/3)
+print(PN)
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(3) Construisez un array numpy `AN`, de la même taille que `N`, donnant le chiffre d'affaires, en fonction du nombre d'unités fabriquées (en supposant que toutes les unités fabriquées sont vendues)")
+AN = N * 5
+print(AN)
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(4) Représentez la courbe P(N) en bleu, et la courbe A(N), en rouge, dans la même figure")
+plt.figure()
+plt.plot(N, PN, color='blue', label='coûts de production')
+plt.plot(N, AN, color='red', label='chiffre d\'affaires')
+plt.legend()		# (utilisera le label associé à chaque courbe au niveau des commandes `plot`)
+
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+
+print("(5) Rajoutez\n",
+ "- une grille de coordonnées,\n",
+ "- des labels *au nom approprié* sur l'axe des abscisses et l'axe des ordonnées.")
+plt.grid()
+plt.xlabel('coûts de production')
+plt.ylabel('chiffre d\'affaires')
+plt.show()
+
+# -------------- Supprimez cette ligne pour passer à la suite ------------------
+z = 0
+
+for i in range(len(N)):
+	if(PN[i]>AN[i]):
+		z = N[i]
+
+print("(6) Estimez le seuil de rentabilité pour le fabricant, à une unité près:")
+print("Le seuil de rentabilité est approximativement de", z,"unités journalières")
+
+

Maths/tp/Bases2/tp2/exo3_equation_parametrique.py

@@ -0,0 +1,23 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Tuple
+
+T = np.linspace(-4, 4, 200)
+
+a, b, c = (2, -1, 2)
+d, e, f = (-3, -1, -1)
+
+def parabole(T: np.array) -> Tuple[np.array, np.array]:
+	XT = a + b * T + c * T * T
+	YT = d + e * T + f * T * T
+	return XT, YT
+
+plt.figure()
+plt.plot(*parabole(T))
+plt.grid()
+
+T = np.arange(-4, 5)
+plt.scatter(*parabole(T))
+
+plt.show()
+

Maths/tp/Bases2/tp2/exo4_equation_parametrique.py

@@ -0,0 +1,34 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Tuple
+
+markers = np.arange(-3, 4)
+def droite(T: np.array, a: int, c: int, b: int, d: int) -> Tuple[Tuple[np.array, np.array], Tuple[np.array, np.array]]:
+	marques = a + b * markers, c + d * markers
+	points = a + b * T, c + d * T
+	return points, marques
+
+T = np.linspace(-3, 3, 200)
+
+plt.figure()
+
+#a = droite(T, 3, 1, 5, 3)
+#plt.plot(*a[0], color='blue')
+#plt.scatter(*a[1])
+a = droite(T, -3, -1, 5, 3)
+plt.plot(*a[0], color='blue')
+a = droite(T, -5, 6, 3, -4)
+plt.plot(*a[0], color='green')
+a = droite(T, 0, 2, 2, -1)
+plt.plot(*a[0], color='red')
+
+plt.grid()
+
+plt.xlim([-5, 5])
+plt.ylim([-5, 5])
+ax = plt.gca()
+ax.set_xticks(range(-5, 6))
+ax.set_yticks(range(-5, 6))
+
+plt.show()
+

Maths/tp/Bases2/tp2/exo5_equation_parametrique.py

@@ -0,0 +1,31 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Tuple
+
+tau = np.pi * 2
+T = np.linspace(0, tau, 16)
+
+def lissajous(n: int, m: int) -> Tuple[np.array, np.array]:
+	C = np.cos(n * T)
+	S = np.sin(m * T)
+	return C, S
+
+def lemniscate_bernouilli() -> Tuple[np.array, np.array]:
+	X = np.sin(T) / (1 + np.cos(T) * np.cos(T))
+	Y = np.sin(T) * np.cos(T) / (1 + np.cos(T) * np.cos(T))
+	return X, Y
+
+def cardioide() -> Tuple[np.array, np.array]:
+	X = np.cos(T) * (1 + np.cos(T))
+	Y = np.sin(T) * (1 + np.cos(T))
+	return X, Y
+
+plt.plot(*lissajous(5, 4), label='courbe de Lissajous') # équivalent à plt.plot(*lissajous(10, 8))
+#plt.plot(*lissajous(7, 3))
+#plt.plot(*lissajous(1, 1))
+plt.plot(*lemniscate_bernouilli(), label='lemniscate de Bernoulli')
+plt.plot(*cardioide(), label='cardioïde')
+plt.grid()
+plt.legend()
+plt.show()
+