arthur/ArtStudies
1
0
Fork 0
mirror of https://github.com/ArthurDanjou/ArtStudies.git synced 2026-02-01 04:29:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactor code for improved readability and consistency across multiple Jupyter notebooks

Browse Source 
- Added missing commas in various print statements and function calls for better syntax.
- Reformatted code to enhance clarity, including breaking long lines and aligning parameters.
- Updated function signatures to use float type for sigma parameters instead of int for better precision.
- Cleaned up comments and documentation strings for clarity and consistency.
- Ensured consistent formatting in plotting functions and data handling.
This commit is contained in:
Arthur Danjou
2025-12-13 23:38:17 +01:00
parent f89ff4a016
commit d5a6bfd339
50 changed files with 779 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
L3/Analyse Matricielle/TP1_Methode_de_Gauss.ipynb
View File

@@ -94,7 +94,7 @@
" [0, 0, 3, 0, 0],\n",
" [0, 0, 0, 4, 0],\n",
" [0, 0, 0, 0, 5],\n",
" ]\n",
" ],\n",
")\n",
"B = np.array(\n",
" [\n",
@@ -103,7 +103,7 @@
" [3, 4, 5, 6, 7],\n",
" [4, 5, 6, 7, 8],\n",
" [5, 6, 7, 8, 9],\n",
" ]\n",
" ],\n",
")\n",
"d = np.diag(A)\n",
"dd = np.array([np.diag(A)])\n",
@@ -299,7 +299,7 @@
" raise ValueError(\"Erreur de dimension : A doit etre carré\")\n",
" if n != b.size:\n",
" raise valueError(\n",
" \"Erreur de dimension : le nombre de lignes de A doit être égal au nombr ede colonnes de b\"\n",
" \"Erreur de dimension : le nombre de lignes de A doit être égal au nombr ede colonnes de b\",\n",
" )\n",
" U = np.zeros((n, n + 1))\n",
" U = A\n",

42
L3/Calculs Numériques/DM1.ipynb
View File

@@ -113,9 +113,7 @@
"\n",
"\n",
"def C(t):\n",
" \"\"\"\n",
" Fonction retournant la solution exacte du problème au temps t\n",
" \"\"\"\n",
" \"\"\"Fonction retournant la solution exacte du problème au temps t\"\"\"\n",
" return K_star + K / (1 + (K / K0 - 1) * np.exp(-r * (t - t_fl)))\n",
"\n",
"\n",
@@ -137,9 +135,7 @@
"\n",
"\n",
"def dN(N, t, C_sol):\n",
" \"\"\"\n",
" Fonction calculant la dérivée de la solution approchée du problème à l'instant t dépendant de N(t) et de C(t)\n",
" \"\"\"\n",
" \"\"\"Fonction calculant la dérivée de la solution approchée du problème à l'instant t dépendant de N(t) et de C(t)\"\"\"\n",
" return r_N * N * (1 - N / C_sol(t))\n",
"\n",
"\n",
@@ -239,13 +235,19 @@
"# On crée une figure à trois graphiques\n",
"fig = plt.figure(figsize=(12, 6))\n",
"ax = fig.add_subplot(\n",
" 1, 2, 2\n",
" 1,\n",
" 2,\n",
" 2,\n",
") # subplot pour le champ de vecteurs et le graphe sardines vs requins\n",
"axr = fig.add_subplot(\n",
" 2, 2, 1\n",
" 2,\n",
" 2,\n",
" 1,\n",
") # subplot pour le graphe du nombre de requins en fonction du temps\n",
"axs = fig.add_subplot(\n",
" 2, 2, 3\n",
" 2,\n",
" 2,\n",
" 3,\n",
") # subplot pour le graphe du nombre de sardines en fonction du temps\n",
"ax.quiver(sardines, requins, fsardines / n_sndmb, frequins / n_sndmb)\n",
"\n",
@@ -317,12 +319,10 @@
"outputs": [],
"source": [
"def crank_nicolson(y0, T, N, r):\n",
" \"\"\"\n",
" schéma de Crank-Nicolson pour le modèle de Malthus\n",
" \"\"\"schéma de Crank-Nicolson pour le modèle de Malthus\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" y0: float\n",
" donnée initiale\n",
" T: float\n",
@@ -334,13 +334,12 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" t: ndarray\n",
" les instants où la solution approchée est calculée\n",
" y: ndarray\n",
" les valeurs de la solution approchée par le theta-schema\n",
" \"\"\"\n",
"\n",
" \"\"\"\n",
" dt = T / N\n",
" t = np.zeros(N + 1)\n",
" y = np.zeros(N + 1)\n",
@@ -357,12 +356,10 @@
"\n",
"\n",
"def euler_explicit(y0, T, N, r):\n",
" \"\"\"\n",
" schéma de d'Euler pour le modèle de Malthus\n",
" \"\"\"schéma de d'Euler pour le modèle de Malthus\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" y0: float\n",
" donnée initiale\n",
" T: float\n",
@@ -374,11 +371,11 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" t: ndarray\n",
" les instants où la solution approchée est calculée\n",
" y: ndarray\n",
" les valeurs de la solution approchée par le theta-schema\n",
"\n",
" \"\"\"\n",
" dt = T / N\n",
" t = np.zeros(N + 1)\n",
@@ -396,9 +393,7 @@
"\n",
"\n",
"def solution_exacte(t):\n",
" \"\"\"\n",
" Fonction calculant la solution exacte du modèle de Malthus à l'instant t\n",
" \"\"\"\n",
" \"\"\"Fonction calculant la solution exacte du modèle de Malthus à l'instant t\"\"\"\n",
" return y0 * np.exp(r * t)"
]
},
@@ -462,7 +457,10 @@
"ax = fig.add_subplot(1, 2, 2)\n",
"for n in liste_N:\n",
" t, y = crank_nicolson(\n",
" y0, T, n, r\n",
" y0,\n",
" T,\n",
" n,\n",
" r,\n",
" ) # On calcule la fonction Crank-Nicolson pour chaque n\n",
" ax.scatter(t, y, label=f\"Solution approchée pour N={n}\")\n",
"ax.plot(t_exact, solution_exacte(t_exact), label=\"Solution exacte\")\n",

36
L3/Calculs Numériques/DM2.ipynb
View File

@@ -151,20 +151,18 @@
],
"source": [
"def M(x):\n",
" \"\"\"\n",
" Retourne la matrice du système (2)\n",
" \"\"\"Retourne la matrice du système (2)\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
"\n",
" Returns\n",
" -------\n",
"\n",
" out: ndarray\n",
" matrice du système (2)\n",
"\n",
" \"\"\"\n",
" h = x[1:] - x[:-1] # x[i+1] - x[i]\n",
" return (\n",
@@ -194,12 +192,10 @@
"outputs": [],
"source": [
"def sprime(x, y, p0, pN):\n",
" \"\"\"\n",
" Retourne la solution du système (2)\n",
" \"\"\"Retourne la solution du système (2)\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" y: ndarray\n",
@@ -211,9 +207,9 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" out: ndarray\n",
" solution du système (2)\n",
"\n",
" \"\"\"\n",
" h = x[1:] - x[:-1]\n",
" delta_y = (y[1:] - y[:-1]) / h\n",
@@ -276,39 +272,35 @@
],
"source": [
"def f(x):\n",
" \"\"\"\n",
" Retourne la fonction f évaluée aux points x\n",
" \"\"\"Retourne la fonction f évaluée aux points x\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
"\n",
" Returns\n",
" -------\n",
"\n",
" out: ndarray\n",
" Valeur de la fonction f aux points x\n",
"\n",
" \"\"\"\n",
" return 1 / (1 + x**2)\n",
"\n",
"\n",
"def fprime(x):\n",
" \"\"\"\n",
" Retourne la fonction dérivée de f évaluée aux points x\n",
" \"\"\"Retourne la fonction dérivée de f évaluée aux points x\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
"\n",
" Returns\n",
" -------\n",
"\n",
" out: ndarray\n",
" Valeur de la fonction dérivée de f aux points x\n",
"\n",
" \"\"\"\n",
" return -2 * x / ((1 + x**2) ** 2)\n",
"\n",
@@ -368,12 +360,10 @@
"outputs": [],
"source": [
"def splines(x, y, p0, pN):\n",
" \"\"\"\n",
" Retourne la matrice S de taille (4, N)\n",
" \"\"\"Retourne la matrice S de taille (4, N)\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" y: ndarray\n",
@@ -385,9 +375,9 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" out: ndarray\n",
" Matrice S de taille (4, N) tel que la i-ième ligne contient les valeurs a_i, b_i, c_i et d_i\n",
"\n",
" \"\"\"\n",
" h = x[1:] - x[:-1]\n",
" delta_y = (y[1:] - y[:-1]) / h\n",
@@ -420,12 +410,10 @@
"outputs": [],
"source": [
"def spline_eval(x, xx, S):\n",
" \"\"\"\n",
" Evalue une spline définie par des noeuds équirepartis\n",
" \"\"\"Evalue une spline définie par des noeuds équirepartis\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" x: ndarray\n",
" noeuds définissant la spline\n",
"\n",
@@ -439,9 +427,9 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" ndarray\n",
" ordonnées des points d'évaluation\n",
"\n",
" \"\"\"\n",
" ind = (np.floor((xx - x[0]) / (x[1] - x[0]))).astype(int)\n",
" ind = np.where(ind == x.size - 1, ind - 1, ind)\n",

44
L3/Calculs Numériques/DM3.ipynb
View File

@@ -180,11 +180,11 @@
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(\n",
" f\"Calcule de I(f) par la méthode de gauss et par la formule quadratique pour la fonction {f.__name__}\"\n",
" f\"Calcule de I(f) par la méthode de gauss et par la formule quadratique pour la fonction {f.__name__}\",\n",
" )\n",
" for n in range(1, 11):\n",
" print(f\"Pour n = {n}, gauss = {gauss(f, n)} et quad = {quad(f, -1, 1)[0]}\")\n",
" print(\"\")"
" print()"
]
},
{
@@ -276,11 +276,11 @@
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(\n",
" f\"Calcule de I(f) par la méthode de simpson et par la formule quadratique pour la fonction {f.__name__}\"\n",
" f\"Calcule de I(f) par la méthode de simpson et par la formule quadratique pour la fonction {f.__name__}\",\n",
" )\n",
" for n in range(3, 16, 2):\n",
" print(f\"Pour n = {n}, simpson = {simpson(f, n)} et quad = {quad(f, -1, 1)[0]}\")\n",
" print(\"\")"
" print()"
]
},
{
@@ -340,10 +340,9 @@
"def poly_tchebychev(x, N):\n",
" if N == 0:\n",
" return np.ones_like(x)\n",
" elif N == 1:\n",
" if N == 1:\n",
" return x\n",
" else:\n",
" return 2 * x * poly_tchebychev(x, N - 1) - poly_tchebychev(x, N - 2)"
" return 2 * x * poly_tchebychev(x, N - 1) - poly_tchebychev(x, N - 2)"
]
},
{
@@ -421,7 +420,7 @@
" print(f\"Pour N = {n}\")\n",
" print(f\"Les points de Tchebychev sont {xk}\")\n",
" print(f\"L'evaluation du polynome de Tchebychev Tn en ces points est {Tn}\")\n",
" print(\"\")"
" print()"
]
},
{
@@ -537,11 +536,11 @@
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(\n",
" f\"Calcule de I(f) par la méthode de fejer et par la formule quadratique pour la fonction {f.__name__}\"\n",
" f\"Calcule de I(f) par la méthode de fejer et par la formule quadratique pour la fonction {f.__name__}\",\n",
" )\n",
" for n in range(1, 11):\n",
" print(f\"Pour n = {n}, fejer = {fejer(f, n)} et quad = {quad(f, -1, 1)[0]}\")\n",
" print(\"\")"
" print()"
]
},
{
@@ -603,7 +602,10 @@
" marker=\"+\",\n",
" )\n",
" ax.scatter(\n",
" np.arange(3, N + 1, 2), np.log10(error_simp), label=\"Simpson\", marker=\"+\"\n",
" np.arange(3, N + 1, 2),\n",
" np.log10(error_simp),\n",
" label=\"Simpson\",\n",
" marker=\"+\",\n",
" )\n",
" ax.scatter(\n",
" np.arange(1, N + 1),\n",
@@ -703,8 +705,14 @@
"print(\"-----------------------------------------------------------------------\")\n",
"print(\n",
" \"{:>5s} | {:>7s} {:>9s} {:>9s} {:>9s} {:>9s} {:>9s}\".format(\n",
" \"N\", \"x^0\", \"x^2\", \"x^4\", \"x^6\", \"x^8\", \"x^10\"\n",
" )\n",
" \"N\",\n",
" \"x^0\",\n",
" \"x^2\",\n",
" \"x^4\",\n",
" \"x^6\",\n",
" \"x^8\",\n",
" \"x^10\",\n",
" ),\n",
")\n",
"print(\"-----------------------------------------------------------------------\")\n",
"\n",
@@ -758,8 +766,14 @@
"print(\"-----------------------------------------------------------------------\")\n",
"print(\n",
" \"{:>5s} | {:>7s} {:>9s} {:>9s} {:>9s} {:>9s} {:>9s}\".format(\n",
" \"N\", \"x^0\", \"x^2\", \"x^4\", \"x^6\", \"x^8\", \"x^10\"\n",
" )\n",
" \"N\",\n",
" \"x^0\",\n",
" \"x^2\",\n",
" \"x^4\",\n",
" \"x^6\",\n",
" \"x^8\",\n",
" \"x^10\",\n",
" ),\n",
")\n",
"print(\"-----------------------------------------------------------------------\")\n",
"\n",

2
L3/Calculs Numériques/Interpolation.ipynb
View File

@@ -527,7 +527,7 @@
" \"\"\"Build the Vandermonde matrix for points x.\"\"\"\n",
" size = x.shape[0]\n",
" M = np.reshape(x, (size, 1))\n",
" power = list(range(0, size))\n",
" power = list(range(size))\n",
" return M**power\n",
"\n",
"\n",

2
L3/Calculs Numériques/Interpolation_2.ipynb
View File

@@ -163,7 +163,7 @@
" [\n",
" (a + b) / 2 + (b - a) / 2 * np.cos((2 * i - 1) / (2 * N) * np.pi)\n",
" for i in range(1, N + 1)\n",
" ]\n",
" ],\n",
" )"
]
},

10
L3/Calculs Numériques/Intégration.ipynb
View File

@@ -151,11 +151,9 @@
" return np.ones_like(x)\n",
" if n == 1:\n",
" return x\n",
" else:\n",
" return (\n",
" (2 * n - 1) * x * poly_legendre(x, n - 1)\n",
" - (n - 1) * poly_legendre(x, n - 2)\n",
" ) / n"
" return (\n",
" (2 * n - 1) * x * poly_legendre(x, n - 1) - (n - 1) * poly_legendre(x, n - 2)\n",
" ) / n"
]
},
{
@@ -509,7 +507,7 @@
" for f in [f0, f1]:\n",
" print(f\"I({f.__name__}) par quad_gauss: {quad_gauss(f, n)}\")\n",
" print(f\"I({f.__name__}) par quad: {quad(f, -1, 1)[0]}\")\n",
" print(\"\")"
" print()"
]
},
{

8
L3/Calculs Numériques/Methode_de_Newton.ipynb
View File

@@ -107,7 +107,7 @@
"\n",
"def f1prime(x):\n",
" \"\"\"Return the value of the derivative of f1 at point x.\"\"\"\n",
" return 2 * np.cos(x) * np.sin(x)\n"
" return 2 * np.cos(x) * np.sin(x)"
]
},
{
@@ -463,7 +463,7 @@
" for n in range(1, 21):\n",
" x_sol = newton(f, fprime, x_start, epsilon, n)\n",
" print(f\"x_sol = {x_sol[1]} pour {x_sol[0]} itérations\")\n",
" print(\"\")\n",
" print()\n",
"\n",
"xx = np.linspace(-3, 3, 200)\n",
"\n",
@@ -526,7 +526,7 @@
"\n",
"# DECOMMENTEZ\n",
"img0 = mpimg.imread(\"image0.png\")\n",
"plt.imshow(img0)\n"
"plt.imshow(img0)"
]
},
{
@@ -757,7 +757,7 @@
"\n",
"\n",
"roots = np.array(\n",
" [complex(-1 / 2, np.sqrt(3) / 2), complex(-1 / 2, -np.sqrt(3) / 2), complex(1, 0)]\n",
" [complex(-1 / 2, np.sqrt(3) / 2), complex(-1 / 2, -np.sqrt(3) / 2), complex(1, 0)],\n",
")"
]
},

6
L3/Calculs Numériques/Point_Fixe.ipynb
View File

@@ -143,12 +143,10 @@
"outputs": [],
"source": [
"def point_fixe(f, x0, tol=1.0e-6, itermax=5000):\n",
" \"\"\"\n",
" Recherche de point fixe : méthode brute x_{n+1} = f(x_n)\n",
" \"\"\"Recherche de point fixe : méthode brute x_{n+1} = f(x_n)\n",
"\n",
" Parameters\n",
" ----------\n",
"\n",
" f: function\n",
" la fonction dont on cherche le point fixe\n",
" x0: float\n",
@@ -160,13 +158,13 @@
"\n",
" Returns\n",
" -------\n",
"\n",
" x: float\n",
" la valeur trouvée pour le point fixe\n",
" niter: int\n",
" le nombre d'itérations effectuées\n",
" xL: ndarray\n",
" la suite des itérés de la suite\n",
"\n",
" \"\"\"\n",
" xL = [x0]\n",
" niter = 0\n",

16
L3/Equations Différentielles/TP1_EDO_EulerExp.ipynb
View File

@@ -135,10 +135,10 @@
"y = np.linspace(0, 2.1, 23) # ordonnées des points de la grille\n",
"T, Y = np.meshgrid(t, y) # grille de points dans le plan (t,y)\n",
"U = np.ones(T.shape) / np.sqrt(\n",
" 1 + f1(T, Y) ** 2\n",
" 1 + f1(T, Y) ** 2,\n",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = f1(T, Y) / np.sqrt(\n",
" 1 + f1(T, Y) ** 2\n",
" 1 + f1(T, Y) ** 2,\n",
") # matrice avec les composantes verticales des vecteurs (f(t,y)), normalisées\n",
"plt.quiver(T, Y, U, V, angles=\"xy\", scale=20, color=\"cyan\")\n",
"plt.axis([-5, 5, 0, 2.1])"
@@ -227,10 +227,10 @@
"y = np.linspace(ymin, ymax) # ordonnées des points de la grille\n",
"T, Y = np.meshgrid(t, y) # grille de points dans le plan (t,y)\n",
"U = np.ones(T.shape) / np.sqrt(\n",
" 1 + f2(T, Y) ** 2\n",
" 1 + f2(T, Y) ** 2,\n",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = f1(T, Y) / np.sqrt(\n",
" 1 + f2(T, Y) ** 2\n",
" 1 + f2(T, Y) ** 2,\n",
") # matrice avec les composantes verticales des vecteurs (f(t,y)), normalisées\n",
"plt.quiver(T, Y, U, V, angles=\"xy\", scale=20, color=\"cyan\")\n",
"plt.axis([xmin, xmax, ymin, ymax])"
@@ -484,10 +484,10 @@
"y = np.linspace(0, K + 100, 23) # ordonnées des points de la grille\n",
"T, P = np.meshgrid(t, y) # grille de points dans le plan (t,y)\n",
"U = np.ones(T.shape) / np.sqrt(\n",
" 1 + fV(T, P) ** 2\n",
" 1 + fV(T, P) ** 2,\n",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = fV(T, P) / np.sqrt(\n",
" 1 + fV(T, P) ** 2\n",
" 1 + fV(T, P) ** 2,\n",
") # matrice avec les composantes verticales des vecteurs (f(t,y)), normalisées\n",
"plt.quiver(T, P, U, V, angles=\"xy\", scale=20, color=\"cyan\")\n",
"plt.legend(fontsize=4)"
@@ -570,10 +570,10 @@
"y = np.linspace(0, 6, 23) # ordonnées des points de la grille\n",
"T, P = np.meshgrid(t, y) # grille de points dans le plan (t,y)\n",
"U = np.ones(T.shape) / np.sqrt(\n",
" 1 + fS(T, P) ** 2\n",
" 1 + fS(T, P) ** 2,\n",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = fS(T, P) / np.sqrt(\n",
" 1 + fS(T, P) ** 2\n",
" 1 + fS(T, P) ** 2,\n",
") # matrice avec les composantes verticales des vecteurs (f(t,y)), normalisées\n",
"plt.quiver(T, P, U, V, angles=\"xy\", scale=20, color=\"cyan\")"
]

2
L3/Equations Différentielles/TP2_Lokta_Volterra.ipynb
View File

@@ -125,7 +125,7 @@
" [\n",
" (C[0] * np.exp(-(t - t0)) * U1[0] + C[1] * np.exp(-2 * (t - t0)) * U2[0]),\n",
" (C[0] * np.exp(-(t - t0)) * U1[1] + C[1] * np.exp(-2 * (t - t0)) * U2[1]),\n",
" ]\n",
" ],\n",
" )\n",
"\n",
"\n",

12
L3/Equations Différentielles/TP3_Convergence.ipynb
View File

@@ -224,7 +224,7 @@
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$y^n$\")\n",
"plt.title(\n",
" \"Solutions approchées de (P) obtenus avec mon_schema pour différentes valeurs du pas h\"\n",
" \"Solutions approchées de (P) obtenus avec mon_schema pour différentes valeurs du pas h\",\n",
")"
]
},
@@ -274,7 +274,7 @@
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$|y(t_n) - y^n|$\")\n",
"plt.title(\n",
" \"différence en valeur absolue entre sol. exacte et sol. approchée par mon_schema, pour différentes valeurs du pas h\"\n",
" \"différence en valeur absolue entre sol. exacte et sol. approchée par mon_schema, pour différentes valeurs du pas h\",\n",
")"
]
},
@@ -357,7 +357,7 @@
"\n",
"plt.legend()\n",
"plt.title(\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\"\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\",\n",
")\n",
"plt.xlabel(\"$log(h)$\")\n",
"plt.ylabel(\"$log(E)$\")"
@@ -674,7 +674,7 @@
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$|y(t_n) - y^n|$\")\n",
"plt.title(\n",
" \"différence en valeur absolue entre sol. exacte et sol. approchée, pour différents schemas\"\n",
" \"différence en valeur absolue entre sol. exacte et sol. approchée, pour différents schemas\",\n",
")"
]
},
@@ -826,7 +826,7 @@
" plt.xlabel(\"$t$\")\n",
" plt.ylabel(\"$y^n$\")\n",
" plt.title(\n",
" f\"Solutions approchées de (P) obtenus avec {schema.__name__} pour différentes valeurs du pas h\"\n",
" f\"Solutions approchées de (P) obtenus avec {schema.__name__} pour différentes valeurs du pas h\",\n",
" )"
]
},
@@ -886,7 +886,7 @@
"\n",
" plt.legend()\n",
" plt.title(\n",
" f\"Erreur pour la méthode {schema.__name__} en echelle logarithmique : log(E) en fonction de log(h)\"\n",
" f\"Erreur pour la méthode {schema.__name__} en echelle logarithmique : log(E) en fonction de log(h)\",\n",
" )\n",
" plt.xlabel(\"$log(h)$\")\n",
" plt.ylabel(\"$log(E)$\")"

18
L3/Méthodes Numériques/TP1_Equation_de_Poisson.ipynb
View File

@@ -361,7 +361,7 @@
"plt.ylabel(r\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\",\n",
")"
]
},
@@ -440,7 +440,7 @@
"plt.xlabel(\"$log(h)$\")\n",
"plt.ylabel(\"$log(E)$\")\n",
"plt.title(\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\"\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\",\n",
")"
]
},
@@ -592,7 +592,7 @@
"plt.ylabel(r\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\",\n",
")"
]
},
@@ -672,7 +672,7 @@
"plt.xlabel(\"$log(h)$\")\n",
"plt.ylabel(\"$log(E)$\")\n",
"plt.title(\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\"\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\",\n",
")"
]
},
@@ -781,7 +781,11 @@
" x, U_app = solution_neumann(f3, M, a, b)\n",
"\n",
" plt.scatter(\n",
" x, U_app, marker=\"+\", s=3, label=\"$h^2({A_N}_h + I_M)U = h^2F$ pour M={M}\"\n",
" x,\n",
" U_app,\n",
" marker=\"+\",\n",
" s=3,\n",
" label=\"$h^2({A_N}_h + I_M)U = h^2F$ pour M={M}\",\n",
" )\n",
"plt.plot(x, u3(x), label=\"Solution exacte\", color=\"red\")\n",
"plt.legend(fontsize=8)\n",
@@ -836,7 +840,7 @@
"plt.ylabel(r\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\",\n",
")"
]
},
@@ -877,7 +881,7 @@
"plt.xlabel(\"$log(h)$\")\n",
"plt.ylabel(\"$log(E)$\")\n",
"plt.title(\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\"\n",
" \"Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)\",\n",
")"
]
},

21
L3/Projet Numérique/Segregation.ipynb
View File

@@ -51,7 +51,9 @@
" def initialisation_grille(self):\n",
" grille = np.zeros((self.M, self.M), dtype=int)\n",
" occupes = np.random.choice(\n",
" self.M * self.M, size=int((1 - self.p) * self.M * self.M), replace=False\n",
" self.M * self.M,\n",
" size=int((1 - self.p) * self.M * self.M),\n",
" replace=False,\n",
" )\n",
" self.Ntot = len(occupes)\n",
"\n",
@@ -82,19 +84,14 @@
" case = self.grille[i, j]\n",
" if case == 0:\n",
" pass\n",
" elif case == groupe:\n",
" count_similaires += 1\n",
" else:\n",
" if case == groupe:\n",
" count_similaires += 1\n",
" else:\n",
" count_differents += 1\n",
" count_differents += 1\n",
"\n",
" if count_similaires + count_differents == 0:\n",
" return False\n",
" else:\n",
" return (\n",
" float(count_similaires / (count_similaires + count_differents))\n",
" >= self.L\n",
" )\n",
" return float(count_similaires / (count_similaires + count_differents)) >= self.L\n",
"\n",
" def clusters(self):\n",
" visited = np.zeros_like(self.grille, dtype=bool)\n",
@@ -179,7 +176,7 @@
" self.grille[agent[0]][agent[1]] = 0\n",
" cases_non_occupees.append(agent)\n",
" self.afficher_grille(\n",
" f\"Configuration Finale de T={T} pour (M, p, L) = ({self.M},{self.p},{self.L})\"\n",
" f\"Configuration Finale de T={T} pour (M, p, L) = ({self.M},{self.p},{self.L})\",\n",
" )"
]
},
@@ -744,7 +741,7 @@
" plt.xlabel(\"L\")\n",
" plt.ylabel(\"S\")\n",
" plt.title(\n",
" f\"Evolution du coefficient de ségrégation S en fonction de la tolérance L = {L} pour p = {p}\"\n",
" f\"Evolution du coefficient de ségrégation S en fonction de la tolérance L = {L} pour p = {p}\",\n",
" )"
]
},

15
L3/Statistiques/TP1.ipynb
View File

@@ -11,7 +11,7 @@
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import scipy.stats as stats"
"from scipy import stats"
]
},
{
@@ -144,7 +144,11 @@
" label=\"Echantillon de X - Y/2\",\n",
")\n",
"plt.hist(\n",
" sampleZ / 2, bins=intervalle, density=True, alpha=0.7, label=\"Echantillon de Z\"\n",
" sampleZ / 2,\n",
" bins=intervalle,\n",
" density=True,\n",
" alpha=0.7,\n",
" label=\"Echantillon de Z\",\n",
")\n",
"plt.legend()"
]
@@ -178,7 +182,10 @@
" sample = np.random.binomial(k, p, nb_repl)\n",
" intervalle = np.linspace(np.min(sample), np.max(sample), 100)\n",
" plt.hist(\n",
" sample, bins=intervalle, density=True, label=f\"Echantillon de X pour n={k}\"\n",
" sample,\n",
" bins=intervalle,\n",
" density=True,\n",
" label=f\"Echantillon de X pour n={k}\",\n",
" )\n",
" plt.legend()"
]
@@ -271,7 +278,7 @@
"\n",
"for _ in range(nb_lgn):\n",
" liste_Sn.append(\n",
" np.mean(np.sqrt(3 * nb_repl) * np.tan(np.pi / 2 * sample_uniforme(nb_repl)))\n",
" np.mean(np.sqrt(3 * nb_repl) * np.tan(np.pi / 2 * sample_uniforme(nb_repl))),\n",
" )\n",
"\n",
"# nb_bins = 100\n",

2
L3/Statistiques/TP2.ipynb
View File

@@ -13,7 +13,7 @@
"import numpy as np\n",
"import scipy.optimize as opt\n",
"import scipy.special as sp\n",
"import scipy.stats as stats"
"from scipy import stats"
]
},
{