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

Refactor code for improved readability and consistency across notebooks

Browse Source 
- Standardized spacing around operators and function arguments in TP7_Kmeans.ipynb and neural_network.ipynb.
- Enhanced the formatting of model building and training code in neural_network.ipynb for better clarity.
- Updated the pyproject.toml to remove a specific TensorFlow version and added linting configuration for Ruff.
- Improved comments and organization in the code to facilitate easier understanding and maintenance.
This commit is contained in:
Arthur Danjou
2025-07-01 20:46:08 +02:00
parent e273cf90f7
commit f94ff07cab
34 changed files with 5713 additions and 5047 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.python-version
View File

@@ -1 +1 @@
3.12
3.13

68
L3/Analyse Matricielle/TP1_Methode_de_Gauss.ipynb
View File

@@ -76,24 +76,40 @@
],
"source": [
"import numpy as np\n",
"\n",
"%matplotlib inline\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"u = np.array([1,2,3,4,5])\n",
"v = np.array([[1,2,3,4,5]])\n",
"su=u.shape\n",
"sv=v.shape\n",
"u = np.array([1, 2, 3, 4, 5])\n",
"v = np.array([[1, 2, 3, 4, 5]])\n",
"su = u.shape\n",
"sv = v.shape\n",
"ut = np.transpose(u)\n",
"vt = np.transpose(v)\n",
"vt2 = np.array([[1],[2],[3],[4],[5]])\n",
"A = np.array([[1,2,0,0,0],[0,2,0,0,0],[0,0,3,0,0],[0,0,0,4,0],[0,0,0,0,5]])\n",
"B = np.array([[1,2,3,4,5],[2,3,4,5,6],[3,4,5,6,7],[4,5,6,7,8],[5,6,7,8,9]])\n",
"d=np.diag(A)\n",
"dd=np.array([np.diag(A)])\n",
"dt=np.transpose(d)\n",
"ddt=np.transpose(dd)\n",
"Ad=np.diag(np.diag(A))\n",
"vt2 = np.array([[1], [2], [3], [4], [5]])\n",
"A = np.array(\n",
" [\n",
" [1, 2, 0, 0, 0],\n",
" [0, 2, 0, 0, 0],\n",
" [0, 0, 3, 0, 0],\n",
" [0, 0, 0, 4, 0],\n",
" [0, 0, 0, 0, 5],\n",
" ]\n",
")\n",
"B = np.array(\n",
" [\n",
" [1, 2, 3, 4, 5],\n",
" [2, 3, 4, 5, 6],\n",
" [3, 4, 5, 6, 7],\n",
" [4, 5, 6, 7, 8],\n",
" [5, 6, 7, 8, 9],\n",
" ]\n",
")\n",
"d = np.diag(A)\n",
"dd = np.array([np.diag(A)])\n",
"dt = np.transpose(d)\n",
"ddt = np.transpose(dd)\n",
"Ad = np.diag(np.diag(A))\n",
"\n",
"print(np.dot(np.linalg.inv(A), A))"
]
@@ -138,11 +154,11 @@
" x = 0 * b\n",
" n = len(b)\n",
" if np.allclose(A, np.triu(A)):\n",
" for i in range(n-1, -1, -1):\n",
" x[i] = (b[i] - np.dot(A[i,i+1:], x[i+1:])) / A[i,i]\n",
" for i in range(n - 1, -1, -1):\n",
" x[i] = (b[i] - np.dot(A[i, i + 1 :], x[i + 1 :])) / A[i, i]\n",
" elif np.allclose(A, np.tril(A)):\n",
" for i in range(n):\n",
" x[i] = (b[i] - np.dot(A[i,:i], x[:i])) / A[i,i]\n",
" x[i] = (b[i] - np.dot(A[i, :i], x[:i])) / A[i, i]\n",
" else:\n",
" raise ValueError(\"A est ni triangulaire supérieure ni triangulaire inférieure\")\n",
" return x"
@@ -171,7 +187,7 @@
"b = np.dot(A, xe)\n",
"x = remontee_descente(A, b)\n",
"\n",
"print(np.dot(x - xe, x-xe))"
"print(np.dot(x - xe, x - xe))"
]
},
{
@@ -263,9 +279,9 @@
" U = A\n",
" n = len(A)\n",
" for j in range(n):\n",
" for i in range(j+1, n):\n",
" beta = U[i,j]/U[j,j]\n",
" U[i,j:] = U[i,j:] - beta * U[j, j:]\n",
" for i in range(j + 1, n):\n",
" beta = U[i, j] / U[j, j]\n",
" U[i, j:] = U[i, j:] - beta * U[j, j:]\n",
" return U"
]
},
@@ -282,14 +298,16 @@
" if n != m:\n",
" raise ValueError(\"Erreur de dimension : A doit etre carré\")\n",
" if n != b.size:\n",
" raise valueError(\"Erreur de dimension : le nombre de lignes de A doit être égal au nombr ede colonnes de b\")\n",
" U = np.zeros((n, n+1))\n",
" raise valueError(\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",
" V = b\n",
" for j in range(n):\n",
" for i in range(j+1, n):\n",
" beta = U[i,j]/U[j,j]\n",
" U[i,j:] = U[i,j:] - beta * U[j, j:]\n",
" for i in range(j + 1, n):\n",
" beta = U[i, j] / U[j, j]\n",
" U[i, j:] = U[i, j:] - beta * U[j, j:]\n",
" V[i] = V[i] - beta * V[j]\n",
" return remontee_descente(U, V)"
]

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

@@ -9,9 +9,9 @@
"%matplotlib inline\n",
"%config InlineBackend.figure_format = 'retina'\n",
"\n",
"import numpy as np # pour les numpy array\n",
"import matplotlib.pyplot as plt # librairie graphique\n",
"from scipy.integrate import odeint # seulement odeint"
"import numpy as np # pour les numpy array\n",
"import matplotlib.pyplot as plt # librairie graphique\n",
"from scipy.integrate import odeint # seulement odeint"
]
},
{
@@ -103,13 +103,14 @@
"source": [
"# Initialisation des variables\n",
"T = 130\n",
"t = np.arange(0, T+1)\n",
"t = np.arange(0, T + 1)\n",
"\n",
"K = 50 # capacité d'accueil maximale du milieu\n",
"K = 50 # capacité d'accueil maximale du milieu\n",
"K_star = 50 # capacité minimale pour maintenir l'espèce\n",
"r = 0.1 # taux de corissance de la capacité d'accueil du milieu.\n",
"t_fl = 30 # la find ed la période de formation.\n",
"K0 = 1 # Valeur initiale de la capacité d'accueil du milieu.\n",
"r = 0.1 # taux de corissance de la capacité d'accueil du milieu.\n",
"t_fl = 30 # la find ed la période de formation.\n",
"K0 = 1 # Valeur initiale de la capacité d'accueil du milieu.\n",
"\n",
"\n",
"def C(t):\n",
" \"\"\"\n",
@@ -117,11 +118,12 @@
" \"\"\"\n",
" return K_star + K / (1 + (K / K0 - 1) * np.exp(-r * (t - t_fl)))\n",
"\n",
"\n",
"# On trace le graphique de la solution exacte\n",
"plt.plot(t, C(t), label=\"C(t)\")\n",
"plt.hlines(K_star, 0, T, linestyle='dotted', label=\"C = K*\", color='red')\n",
"plt.hlines(K + K_star, 0, T, linestyle='dotted', label=\"C = K + K*\", color='green')\n",
"plt.plot(t_fl, K0 + K_star, 'o', label=\"(t_fl, K0 + K*)\")\n",
"plt.hlines(K_star, 0, T, linestyle=\"dotted\", label=\"C = K*\", color=\"red\")\n",
"plt.hlines(K + K_star, 0, T, linestyle=\"dotted\", label=\"C = K + K*\", color=\"green\")\n",
"plt.plot(t_fl, K0 + K_star, \"o\", label=\"(t_fl, K0 + K*)\")\n",
"plt.legend()\n",
"plt.xlim(0, 130)\n",
"plt.suptitle(\"Courbe de la solution exacte du problème\")\n",
@@ -133,14 +135,16 @@
"N0 = 10\n",
"r_N = 0.2\n",
"\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",
" return r_N * N * (1 - N / C_sol(t))\n",
"\n",
"\n",
"t = np.linspace(0, T, 200)\n",
"N_sol = odeint(dN, N0, t, args=(C,)) # On calcule la solution a l'aide de odeint\n",
"N_sol = odeint(dN, N0, t, args=(C,)) # On calcule la solution a l'aide de odeint\n",
"\n",
"# On trace le graphique de la solution approchée en comparaison à la solution exacte\n",
"plt.plot(t, N_sol, label=\"Solution approchée\")\n",
@@ -219,42 +223,47 @@
"T, N = 200, 100\n",
"H0, P0 = 1500, 500\n",
"\n",
"\n",
"def F(X, t, a, b, c, d, p):\n",
" \"\"\"Fonction second membre pour le système\"\"\"\n",
" x, y = X\n",
" return np.array([x * (a - p - b*y), y * (-c - p + d*x)])\n",
" return np.array([x * (a - p - b * y), y * (-c - p + d * x)])\n",
"\n",
"t = np.linspace(0, T, N+1)\n",
"sardines, requins = np.meshgrid(\n",
" np.linspace(0.1, 3000, 20),\n",
" np.linspace(0.1, 4500, 30)\n",
")\n",
"\n",
"t = np.linspace(0, T, N + 1)\n",
"sardines, requins = np.meshgrid(np.linspace(0.1, 3000, 20), np.linspace(0.1, 4500, 30))\n",
"fsardines = F((sardines, requins), t, a, b, c, d, 0)[0]\n",
"frequins = F((sardines, requins), t, a, b, c, d, 0)[1]\n",
"n_sndmb = np.sqrt(fsardines**2 + frequins**2) \n",
"n_sndmb = np.sqrt(fsardines**2 + frequins**2)\n",
"\n",
"# On crée une figure à trois graphiques\n",
"fig = plt.figure(figsize=(12, 6))\n",
"ax = fig.add_subplot(1, 2, 2) # subplot pour le champ de vecteurs et le graphe sardines vs requins\n",
"axr = fig.add_subplot(2, 2, 1) # subplot pour le graphe du nombre de requins en fonction du temps\n",
"axs = fig.add_subplot(2, 2, 3) # subplot pour le graphe du nombre de sardines en fonction du temps \n",
"ax.quiver(sardines, requins, fsardines/n_sndmb, frequins/n_sndmb)\n",
"ax = fig.add_subplot(\n",
" 1, 2, 2\n",
") # subplot pour le champ de vecteurs et le graphe sardines vs requins\n",
"axr = fig.add_subplot(\n",
" 2, 2, 1\n",
") # subplot pour le graphe du nombre de requins en fonction du temps\n",
"axs = fig.add_subplot(\n",
" 2, 2, 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",
"list_p = [0, 0.02, 0.04, 0.06]\n",
"for k, pk in enumerate(list_p):\n",
" couleur = (0, k/len(list_p), 1-k/len(list_p))\n",
" couleur = (0, k / len(list_p), 1 - k / len(list_p))\n",
" X = odeint(F, np.array([H0, P0]), t, args=(a, b, c, d, pk))\n",
" \n",
" # Tracer la courbe parametrée (H(t),P(t)) \n",
"\n",
" # Tracer la courbe parametrée (H(t),P(t))\n",
" ax.plot(X[:, 0], X[:, 1], linewidth=2, color=couleur, label=f\"$p={pk}$\")\n",
" \n",
" # Tracer H en fonction du temps \n",
"\n",
" # Tracer H en fonction du temps\n",
" axs.plot(t, X[:, 0], label=f\"Sardines pour p={pk}\", color=couleur)\n",
" \n",
"\n",
" # Tracer P en fonction du temps\n",
" axr.plot(t, X[:, 1], label=f\"Requins pour p={pk}\", color=couleur)\n",
" \n",
"ax.axis('equal')\n",
"\n",
"ax.axis(\"equal\")\n",
"ax.set_title(\"Champ de vecteur du problème de Lotka-Volterra\")\n",
"ax.set_xlabel(\"Sardines\")\n",
"ax.set_ylabel(\"Requins\")\n",
@@ -266,8 +275,8 @@
"axs.set_xlabel(\"Temps t\")\n",
"axs.set_ylabel(\"Sardines\")\n",
"\n",
"axs.set_title('Evolution des sardines')\n",
"axr.set_title('Evolution des requins')\n",
"axs.set_title(\"Evolution des sardines\")\n",
"axr.set_title(\"Evolution des requins\")\n",
"plt.show()"
]
},
@@ -309,11 +318,11 @@
"source": [
"def crank_nicolson(y0, T, N, r):\n",
" \"\"\"\n",
" schéma de Crank-Nicolson pour le modèle de Malthus \n",
" \n",
" schéma de Crank-Nicolson pour le modèle de Malthus\n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" y0: float\n",
" donnée initiale\n",
" T: float\n",
@@ -325,34 +334,35 @@
"\n",
" Returns\n",
" -------\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",
" t = np.zeros(N + 1)\n",
" y = np.zeros(N + 1)\n",
" tk, yk = 0, y0\n",
" y[0] = yk\n",
" \n",
"\n",
" for n in range(N):\n",
" tk += dt\n",
" yk *= (2 + dt * r) / (2 - dt * r)\n",
" y[n+1] = yk\n",
" t[n+1] = tk\n",
" \n",
" y[n + 1] = yk\n",
" t[n + 1] = tk\n",
"\n",
" return t, y\n",
"\n",
"\n",
"def euler_explicit(y0, T, N, r):\n",
" \"\"\"\n",
" schéma de d'Euler pour le modèle de Malthus \n",
" \n",
" schéma de d'Euler pour le modèle de Malthus\n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" y0: float\n",
" donnée initiale\n",
" T: float\n",
@@ -364,29 +374,30 @@
"\n",
" Returns\n",
" -------\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",
" dt = T / N\n",
" t = np.zeros(N+1)\n",
" y = np.zeros(N+1)\n",
" t = np.zeros(N + 1)\n",
" y = np.zeros(N + 1)\n",
" tk, yk = 0, y0\n",
" y[0] = yk\n",
" \n",
"\n",
" for n in range(N):\n",
" tk += dt\n",
" yk += dt * r * yk\n",
" y[n+1] = yk\n",
" t[n+1] = tk\n",
" \n",
" y[n + 1] = yk\n",
" t[n + 1] = tk\n",
"\n",
" return t, y\n",
"\n",
"\n",
"def solution_exacte(t):\n",
" \"\"\"\n",
" Fonction calculant la solution exacte du modèle de Malthus à l'instant t \n",
" Fonction calculant la solution exacte du modèle de Malthus à l'instant t\n",
" \"\"\"\n",
" return y0 * np.exp(r * t)"
]
@@ -436,23 +447,25 @@
"# Schéma d'Euler explicite\n",
"ax = fig.add_subplot(1, 2, 1)\n",
"for n in liste_N:\n",
" t, y = euler_explicit(y0, T, n, r) # On calcule la fonction Euler pour chaque n\n",
" t, y = euler_explicit(y0, T, n, r) # On calcule la fonction Euler pour chaque n\n",
" ax.scatter(t, y, label=f\"Solution approchée pour N={n}\")\n",
" \n",
"ax.plot(t_exact, solution_exacte(t_exact), label='Solution exacte')\n",
"\n",
"ax.plot(t_exact, solution_exacte(t_exact), label=\"Solution exacte\")\n",
"ax.legend()\n",
"ax.axis('equal')\n",
"ax.axis(\"equal\")\n",
"ax.set_title(\"Schéma d'Euler explicite\")\n",
"ax.set_xlabel(\"Temps t\")\n",
"ax.set_ylabel(\"y\")\n",
" \n",
"\n",
"\n",
"# Schéma de Crank-Nicolson\n",
"ax = fig.add_subplot(1, 2, 2)\n",
"for n in liste_N:\n",
" t, y = crank_nicolson(y0, T, n, r) # On calcule la fonction Crank-Nicolson pour chaque n\n",
" t, y = crank_nicolson(\n",
" y0, T, 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",
"ax.plot(t_exact, solution_exacte(t_exact), label=\"Solution exacte\")\n",
"ax.legend()\n",
"ax.set_title(\"Schéma de Crank-Nicolson\")\n",
"ax.set_xlabel(\"Temps t\")\n",
@@ -504,7 +517,7 @@
" t, sol_appr = crank_nicolson(y0, T, n, r)\n",
" sol_ex = solution_exacte(t)\n",
" erreur = np.max(np.abs(sol_appr - sol_ex))\n",
" #erreur = np.linalg.norm(sol_appr - sol_ex, np.inf)\n",
" # erreur = np.linalg.norm(sol_appr - sol_ex, np.inf)\n",
" print(f\"Delta_t = {T / N:10.3e}, e = {erreur:10.3e}\")\n",
" liste_erreur[k] = erreur\n",
"\n",
@@ -514,7 +527,7 @@
"ax.scatter(liste_delta, liste_erreur, color=\"black\")\n",
"for p in [0.5, 1, 2]:\n",
" C = liste_erreur[-1] / (liste_delta[-1] ** p)\n",
" plt.plot(liste_delta, C * liste_delta ** p, label=f\"$p={p}$\")\n",
" plt.plot(liste_delta, C * liste_delta**p, label=f\"$p={p}$\")\n",
"ax.set_title(\"Erreur du schéma de Crank-Nicolson\")\n",
"ax.set_xlabel(r\"$\\Delta t$\")\n",
"ax.set_ylabel(r\"$e(\\Delta t)$\")\n",

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

@@ -153,22 +153,27 @@
"def M(x):\n",
" \"\"\"\n",
" Retourne la matrice du système (2)\n",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" out: ndarray\n",
" matrice du système (2)\n",
" \"\"\"\n",
" h = x[1:] - x[:-1] # x[i+1] - x[i]\n",
" return np.diag(2*(1/h[:-1] + 1/h[1:])) + np.diag(1/h[1:-1], k=-1) + np.diag(1/h[1:-1], k=1)\n",
" \n",
" h = x[1:] - x[:-1] # x[i+1] - x[i]\n",
" return (\n",
" np.diag(2 * (1 / h[:-1] + 1 / h[1:]))\n",
" + np.diag(1 / h[1:-1], k=-1)\n",
" + np.diag(1 / h[1:-1], k=1)\n",
" )\n",
"\n",
"\n",
"# Test\n",
"print(M(np.array([0, 1, 2, 3, 4])))"
]
@@ -191,10 +196,10 @@
"def sprime(x, y, p0, pN):\n",
" \"\"\"\n",
" Retourne la solution du système (2)\n",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" y: ndarray\n",
@@ -203,18 +208,18 @@
" première valeur du vecteur p\n",
" pN: int\n",
" N-ième valeur du vecteur p\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" out: ndarray\n",
" solution du système (2)\n",
" \"\"\"\n",
" h = x[1:] - x[:-1]\n",
" delta_y = (y[1:] - y[:-1]) / h\n",
" c = 3 * (delta_y[1:]/h[1:] + delta_y[:-1]/h[:-1])\n",
" c[0] -= p0/h[0]\n",
" c[-1] -= pN/h[-1]\n",
" c = 3 * (delta_y[1:] / h[1:] + delta_y[:-1] / h[:-1])\n",
" c[0] -= p0 / h[0]\n",
" c[-1] -= pN / h[-1]\n",
" return np.linalg.solve(M(x), c)"
]
},
@@ -273,52 +278,54 @@
"def f(x):\n",
" \"\"\"\n",
" Retourne la fonction f évaluée aux points x\n",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" out: ndarray\n",
" Valeur de la fonction f aux points x\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",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" out: ndarray\n",
" Valeur de la fonction dérivée de f aux points x\n",
" \"\"\"\n",
" return -2*x/((1+x**2)**2)\n",
" return -2 * x / ((1 + x**2) ** 2)\n",
"\n",
"# Paramètres \n",
"\n",
"# Paramètres\n",
"xx = np.linspace(-5, 5, 200)\n",
"x = np.linspace(-5, 5, 21)\n",
"pi = sprime(x, f(x), fprime(-5), fprime(5))\n",
"\n",
"# Graphique\n",
"fig, ax = plt.subplots(figsize=(6, 6))\n",
"ax.plot(xx, fprime(xx), label=f'$f\\'$', color='red')\n",
"ax.scatter(x[1:-1], pi, label=f'$p_i$')\n",
"ax.plot(xx, fprime(xx), label=\"$f'$\", color=\"red\")\n",
"ax.scatter(x[1:-1], pi, label=\"$p_i$\")\n",
"ax.legend()\n",
"ax.set_xlabel(f'$x$')\n",
"ax.set_ylabel(f'$f(x)$')\n",
"ax.set_title('Les pentes de la spline cubique')"
"ax.set_xlabel(\"$x$\")\n",
"ax.set_ylabel(\"$f(x)$\")\n",
"ax.set_title(\"Les pentes de la spline cubique\")"
]
},
{
@@ -363,10 +370,10 @@
"def splines(x, y, p0, pN):\n",
" \"\"\"\n",
" Retourne la matrice S de taille (4, N)\n",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" vecteurs contenant les valeurs [x0, x1, ..., xN]\n",
" y: ndarray\n",
@@ -375,20 +382,20 @@
" première valeur du vecteur p\n",
" pN: int\n",
" N-ième valeur du vecteur p\n",
" \n",
"\n",
" Returns\n",
" -------\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",
" h = x[1:] - x[:-1]\n",
" delta_y = (y[1:] - y[:-1]) / h\n",
" \n",
"\n",
" a = y\n",
" b = np.concatenate((np.array([p0]), sprime(x, y, p0, pN), np.array([pN])))\n",
" c = 3/h * delta_y - (b[1:] + 2*b[:-1]) / h\n",
" d = 1/h**2 * (b[1:] + b[:-1]) - 2/h**2 * delta_y\n",
" c = 3 / h * delta_y - (b[1:] + 2 * b[:-1]) / h\n",
" d = 1 / h**2 * (b[1:] + b[:-1]) - 2 / h**2 * delta_y\n",
" return np.transpose([a[:-1], b[:-1], c, d])"
]
},
@@ -412,34 +419,38 @@
},
"outputs": [],
"source": [
"def spline_eval( x, xx, S ):\n",
"def spline_eval(x, xx, S):\n",
" \"\"\"\n",
" Evalue une spline définie par des noeuds équirepartis\n",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" x: ndarray\n",
" noeuds définissant la spline\n",
" \n",
"\n",
" xx: ndarray\n",
" abscisses des points d'évaluation\n",
" \n",
"\n",
" S: ndarray\n",
" de taille (x.size-1, 4)\n",
" tableau dont la i-ème ligne contient les coéficients du polynome cubique qui est la restriction\n",
" de la spline à l'intervalle [x_i, x_{i+1}]\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" ndarray\n",
" ordonnées des points d'évaluation\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",
" yy = S[ ind, 0 ] + S[ ind, 1 ] * ( xx - x[ ind ] ) + \\\n",
" S[ ind, 2 ] * ( xx - x[ ind ] )**2 + S[ ind, 3 ] * ( xx - x[ ind ] )**3\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",
" yy = (\n",
" S[ind, 0]\n",
" + S[ind, 1] * (xx - x[ind])\n",
" + S[ind, 2] * (xx - x[ind]) ** 2\n",
" + S[ind, 3] * (xx - x[ind]) ** 3\n",
" )\n",
" return yy"
]
},
@@ -472,21 +483,21 @@
}
],
"source": [
"# Paramètres \n",
"# Paramètres\n",
"x = np.linspace(-5, 5, 6)\n",
"y = np.random.rand(5+1)\n",
"y = np.random.rand(5 + 1)\n",
"xx = np.linspace(-5, 5, 200)\n",
"s = splines(x, y, 0, 0)\n",
"s_eval = spline_eval(x, xx, s)\n",
"\n",
"# Graphique\n",
"fig, ax = plt.subplots(figsize=(6, 6))\n",
"ax.plot(xx, s_eval, label='spline cubique interpolateur', color='red')\n",
"ax.scatter(x, y, label=f'$(x_i, y_i)$')\n",
"ax.plot(xx, s_eval, label=\"spline cubique interpolateur\", color=\"red\")\n",
"ax.scatter(x, y, label=\"$(x_i, y_i)$\")\n",
"ax.legend()\n",
"ax.set_xlabel(f'$x$')\n",
"ax.set_ylabel(f'$f(x)$')\n",
"ax.set_title('Evaluation de la spline cubique')"
"ax.set_xlabel(\"$x$\")\n",
"ax.set_ylabel(\"$f(x)$\")\n",
"ax.set_title(\"Evaluation de la spline cubique\")"
]
},
{
@@ -525,7 +536,7 @@
}
],
"source": [
"# Paramètres \n",
"# Paramètres\n",
"a, b = -5, 5\n",
"N_list = [4, 9, 19]\n",
"\n",
@@ -533,17 +544,17 @@
"fig, ax = plt.subplots(figsize=(15, 6))\n",
"\n",
"for N in N_list:\n",
" x = np.linspace(a, b, N+1)\n",
" x = np.linspace(a, b, N + 1)\n",
" xx = np.linspace(a, b, 200)\n",
" s = splines(x, f(x), 0, 0)\n",
" s_eval = spline_eval(x, xx, s)\n",
" ax.plot(xx, s_eval, label=f'Spline cubique interpolateur pour N={N}')\n",
" ax.scatter(x, f(x), label=f'f(x) pour N={N}')\n",
" \n",
" ax.plot(xx, s_eval, label=f\"Spline cubique interpolateur pour N={N}\")\n",
" ax.scatter(x, f(x), label=f\"f(x) pour N={N}\")\n",
"\n",
"ax.legend()\n",
"ax.set_xlabel(f'$x$')\n",
"ax.set_ylabel(f'$f(x)$')\n",
"ax.set_title('Evaluation de la spline cubique')"
"ax.set_xlabel(\"$x$\")\n",
"ax.set_ylabel(\"$f(x)$\")\n",
"ax.set_title(\"Evaluation de la spline cubique\")"
]
},
{

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

@@ -60,17 +60,20 @@
},
"outputs": [],
"source": [
"def f0(x): \n",
"def f0(x):\n",
" return np.exp(x)\n",
"\n",
"\n",
"def f1(x):\n",
" return 1 / (1 + 16*np.power(x, 2))\n",
" return 1 / (1 + 16 * np.power(x, 2))\n",
"\n",
"\n",
"def f2(x):\n",
" return np.power(np.abs(x**2 - 1/4), 3)\n",
" return np.power(np.abs(x**2 - 1 / 4), 3)\n",
"\n",
"\n",
"def f3(x):\n",
" return np.power(np.abs(x+1/2), 1/2)"
" return np.power(np.abs(x + 1 / 2), 1 / 2)"
]
},
{
@@ -176,10 +179,12 @@
],
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(f'Calcule de I(f) par la méthode de gauss et par la formule quadratique pour la fonction {f.__name__}')\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",
" )\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(\"\")"
]
},
{
@@ -211,10 +216,10 @@
"def simpson(f, N):\n",
" if N % 2 == 0:\n",
" raise ValueError(\"N doit est impair.\")\n",
" \n",
"\n",
" h = 2 / (2 * (N - 1) // 2)\n",
" fx = f(np.linspace(-1, 1, N))\n",
" \n",
"\n",
" return (h / 3) * (fx[0] + 4 * fx[1:-1:2].sum() + 2 * fx[2:-1:2].sum() + fx[-1])"
]
},
@@ -270,10 +275,12 @@
],
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(f'Calcule de I(f) par la méthode de simpson et par la formule quadratique pour la fonction {f.__name__}')\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",
" )\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(\"\")"
]
},
{
@@ -336,7 +343,7 @@
" elif 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)"
]
},
{
@@ -346,7 +353,7 @@
"outputs": [],
"source": [
"def points_tchebychev(N):\n",
" k = np.arange(1, N+1)\n",
" k = np.arange(1, N + 1)\n",
" return np.cos((2 * k - 1) * np.pi / (2 * N))"
]
},
@@ -449,7 +456,7 @@
" lamk = np.zeros(N)\n",
" for k in range(N):\n",
" s = 0\n",
" for m in range(1, N//2+1):\n",
" for m in range(1, N // 2 + 1):\n",
" T = poly_tchebychev(xk[k], 2 * m)\n",
" s += 2 * T / (4 * np.power(m, 2) - 1)\n",
" lamk[k] = 2 / N * (1 - s)\n",
@@ -529,10 +536,12 @@
],
"source": [
"for f in [f0, f1, f2, f3]:\n",
" print(f'Calcule de I(f) par la méthode de fejer et par la formule quadratique pour la fonction {f.__name__}')\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",
" )\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(\"\")"
]
},
{
@@ -568,26 +577,44 @@
"figure = plt.figure(figsize=(15, 10))\n",
"for fi, f in enumerate([f0, f1, f2, f3]):\n",
" error_gauss = np.zeros((N,))\n",
" error_simp = np.zeros(((N-1)//2,))\n",
" error_simp = np.zeros(((N - 1) // 2,))\n",
" error_fejer = np.zeros((N,))\n",
" I_quad, _ = quad(f, -1, 1)\n",
" \n",
" for n in range(1, N+1):\n",
"\n",
" for n in range(1, N + 1):\n",
" I_gauss = gauss(f, n)\n",
" error_gauss[n-1] = np.abs(I_gauss - I_quad)\n",
" error_gauss[n - 1] = np.abs(I_gauss - I_quad)\n",
" I_fejer = fejer(f, n)\n",
" error_fejer[n-1] = np.abs(I_fejer - I_quad)\n",
" \n",
" for n in range( 3, N+1, 2 ):\n",
" error_fejer[n - 1] = np.abs(I_fejer - I_quad)\n",
"\n",
" for n in range(3, N + 1, 2):\n",
" I_simp = simpson(f, n)\n",
" error_simp[(n-2)//2] = np.abs(I_simp - I_quad)\n",
" \n",
" error_simp[(n - 2) // 2] = np.abs(I_simp - I_quad)\n",
"\n",
" ax = figure.add_subplot(2, 2, fi + 1)\n",
" ax.scatter(np.arange(1, N+1), np.log10(error_gauss, out = -16. * np.ones(error_gauss.shape), \n",
" where = (error_gauss > 1e-16)), label = 'Gauss', marker=\"+\")\n",
" ax.scatter(np.arange(3, N+1, 2), np.log10( error_simp ), label = 'Simpson', marker=\"+\")\n",
" ax.scatter(np.arange(1, N+1), np.log10(error_fejer, out = -16. * np.ones(error_fejer.shape), \n",
" where = (error_fejer > 1e-16)), label = 'Fejer', marker=\"+\")\n",
" ax.scatter(\n",
" np.arange(1, N + 1),\n",
" np.log10(\n",
" error_gauss,\n",
" out=-16.0 * np.ones(error_gauss.shape),\n",
" where=(error_gauss > 1e-16),\n",
" ),\n",
" label=\"Gauss\",\n",
" marker=\"+\",\n",
" )\n",
" ax.scatter(\n",
" np.arange(3, N + 1, 2), np.log10(error_simp), label=\"Simpson\", marker=\"+\"\n",
" )\n",
" ax.scatter(\n",
" np.arange(1, N + 1),\n",
" np.log10(\n",
" error_fejer,\n",
" out=-16.0 * np.ones(error_fejer.shape),\n",
" where=(error_fejer > 1e-16),\n",
" ),\n",
" label=\"Fejer\",\n",
" marker=\"+\",\n",
" )\n",
" ax.legend()\n",
" ax.set_title(f\"Erreur de différentes méthodes de quadrature pour {f.__name__}\")\n",
" ax.set_xlabel(\"n\")\n",
@@ -672,8 +699,13 @@
"def f(x, k):\n",
" return x**k\n",
"\n",
"\n",
"print(\"-----------------------------------------------------------------------\")\n",
"print(\"{:>5s} | {:>7s} {:>9s} {:>9s} {:>9s} {:>9s} {:>9s}\".format(\"N\", \"x^0\", \"x^2\", \"x^4\", \"x^6\", \"x^8\", \"x^10\"))\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",
"print(\"-----------------------------------------------------------------------\")\n",
"\n",
"for N in range(1, 11):\n",
@@ -683,7 +715,10 @@
" I_exact = 2 / (k + 1) if k % 2 == 0 else 0\n",
" approx_error = np.abs(I_approx - I_exact)\n",
" approx_errors.append(approx_error)\n",
" print(\"{:5d} | \".format(N) + \" \".join(\"{:.3f} \".format(e) for e in approx_errors))"
" print(\n",
" \"{:5d} | \".format(N)\n",
" + \" \".join(\"{:.3f} \".format(e) for e in approx_errors)\n",
" )"
]
},
{
@@ -722,8 +757,13 @@
"def f(x, k):\n",
" return x**k\n",
"\n",
"\n",
"print(\"-----------------------------------------------------------------------\")\n",
"print(\"{:>5s} | {:>7s} {:>9s} {:>9s} {:>9s} {:>9s} {:>9s}\".format(\"N\", \"x^0\", \"x^2\", \"x^4\", \"x^6\", \"x^8\", \"x^10\"))\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",
"print(\"-----------------------------------------------------------------------\")\n",
"\n",
"for N in range(1, 11):\n",
@@ -733,7 +773,10 @@
" I_exact = 2 / (k + 1) if k % 2 == 0 else 0\n",
" approx_error = np.abs(I_approx - I_exact)\n",
" approx_errors.append(approx_error)\n",
" print(\"{:5d} | \".format(N) + \" \".join(\"{:.3f} \".format(e) for e in approx_errors))"
" print(\n",
" \"{:5d} | \".format(N)\n",
" + \" \".join(\"{:.3f} \".format(e) for e in approx_errors)\n",
" )"
]
},
{

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

@@ -22,8 +22,8 @@
"%matplotlib inline\n",
"%config InlineBackend.figure_format = 'retina'\n",
"\n",
"import numpy as np # pour les numpy array\n",
"import matplotlib.pyplot as plt # librairie graphique"
"import numpy as np # pour les numpy array\n",
"import matplotlib.pyplot as plt # librairie graphique"
]
},
{
@@ -72,11 +72,11 @@
" N = len(x)\n",
" M = len(xx)\n",
" L = np.ones((M, N))\n",
" \n",
"\n",
" for i in range(N):\n",
" for j in range(N):\n",
" if i != j:\n",
" L[:, i] *= (xx - x[j])/(x[i]-x[j])\n",
" L[:, i] *= (xx - x[j]) / (x[i] - x[j])\n",
" return L.dot(y)"
]
},
@@ -119,7 +119,7 @@
"y = np.random.rand(N)\n",
"xx = np.linspace(0, 1, 200)\n",
"\n",
"plt.scatter(x,y)\n",
"plt.scatter(x, y)\n",
"plt.plot(xx, interp_Lagrange(x, y, xx))"
]
},
@@ -155,10 +155,16 @@
"outputs": [],
"source": [
"def equirepartis(a, b, N):\n",
" return np.array([a + (b-a) * (i-1)/(N-1) for i in range(1, N+1)])\n",
" \n",
" return np.array([a + (b - a) * (i - 1) / (N - 1) for i in range(1, N + 1)])\n",
"\n",
"\n",
"def tchebychev(a, b, N):\n",
" return np.array([(a+b)/2 + (b-a)/2 * np.cos((2*i-1)/(2*N)*np.pi) for i in range(1, N+1)])"
" return np.array(\n",
" [\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",
" )"
]
},
{
@@ -188,7 +194,7 @@
" L = np.ones_like(xx)\n",
" for j in range(N):\n",
" if i != j:\n",
" L *= (xx-x[j])/(x[i]-x[j]) \n",
" L *= (xx - x[j]) / (x[i] - x[j])\n",
" return L"
]
},
@@ -271,16 +277,16 @@
" ax[0].set_title(f\"Points équi-repartis (N={n})\")\n",
" xeq = equirepartis(a, b, n)\n",
" for i in range(n):\n",
" ax[0].scatter(xeq[i], 0, color='black')\n",
" ax[0].scatter(xeq[i], 1, color='black')\n",
" ax[0].scatter(xeq[i], 0, color=\"black\")\n",
" ax[0].scatter(xeq[i], 1, color=\"black\")\n",
" ax[0].plot(xx, Li(i, xeq, xx))\n",
" ax[0].grid()\n",
" \n",
"\n",
" ax[1].set_title(f\"Points de Tchebychev (N={n})\")\n",
" xchev = tchebychev(a, b, n)\n",
" for i in range(n):\n",
" ax[1].scatter(xchev[i], 0, color='black')\n",
" ax[1].scatter(xchev[i], 1, color='black')\n",
" ax[1].scatter(xchev[i], 0, color=\"black\")\n",
" ax[1].scatter(xchev[i], 1, color=\"black\")\n",
" ax[1].plot(xx, Li(i, xchev, xx))\n",
" ax[1].grid()"
]
@@ -325,20 +331,20 @@
}
],
"source": [
"f = lambda x: 1/(1+x**2)\n",
"f = lambda x: 1 / (1 + x**2)\n",
"a, b = -5, 5\n",
"xx = np.linspace(a, b, 200)\n",
"\n",
"plt.plot(xx, f(xx), label='Courbe de f')\n",
"plt.plot(xx, f(xx), label=\"Courbe de f\")\n",
"for n in [5, 10, 20]:\n",
" xeq = equirepartis(a, b, n)\n",
" for i in range(n):\n",
" plt.scatter(xeq[i], f(xeq[i]))\n",
" plt.plot(xx, Li(i, xeq, xx))\n",
" \n",
"\n",
"plt.ylim(-1, 1)\n",
"plt.legend()\n",
"plt.title('Interpolation de f avec Lagrange pour N points répartis')\n",
"plt.title(\"Interpolation de f avec Lagrange pour N points répartis\")\n",
"plt.grid()"
]
},
@@ -366,20 +372,20 @@
}
],
"source": [
"f = lambda x: 1/(1+x**2)\n",
"f = lambda x: 1 / (1 + x**2)\n",
"a, b = -5, 5\n",
"xx = np.linspace(a, b, 200)\n",
"\n",
"plt.plot(xx, f(xx), label='Courbe de f')\n",
"plt.plot(xx, f(xx), label=\"Courbe de f\")\n",
"\n",
"for n in [5, 10, 20]:\n",
" xchev = tchebychev(a, b, n)\n",
" for i in range(n):\n",
" plt.scatter(xchev[i], f(xchev[i]))\n",
" plt.plot(xx, Li(i, xchev, xx))\n",
" \n",
"\n",
"plt.legend()\n",
"plt.title('Interpolation de f avec Lagrange pour N points de Tchebychev')\n",
"plt.title(\"Interpolation de f avec Lagrange pour N points de Tchebychev\")\n",
"plt.grid()"
]
},
@@ -437,9 +443,11 @@
"source": [
"N = np.arange(5, 101, 5)\n",
"\n",
"\n",
"def n_inf(f, p):\n",
" return np.max([f, p])\n",
"\n",
"\n",
"# Norme inf en fct de N\n",
"for n in N:\n",
" xeq = equirepartis(a, b, n)\n",

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

@@ -98,16 +98,16 @@
"\n",
"x = np.linspace(-1, 1, 200)\n",
"ax = fig.add_subplot(3, 3, 1)\n",
"ax.plot(x, f1(x), label='Courbe f')\n",
"ax.plot(x, x, label=f'$y=x$')\n",
"ax.plot(x, f1(x), label=\"Courbe f\")\n",
"ax.plot(x, x, label=\"$y=x$\")\n",
"ax.scatter([i for i in x if f1(i) == i], [f1(i) for i in x if f1(i) == i])\n",
"ax.legend()\n",
"\n",
"x = np.linspace(-np.pi / 2, 5*np.pi / 2)\n",
"x = np.linspace(-np.pi / 2, 5 * np.pi / 2)\n",
"for fk, f in enumerate([f2, f3, f4, f5]):\n",
" ax = fig.add_subplot(3, 3, fk+2)\n",
" ax.plot(x, f(x), label='Courbe f')\n",
" ax.plot(x, x, label=f'$y=x$')\n",
" ax = fig.add_subplot(3, 3, fk + 2)\n",
" ax.plot(x, f(x), label=\"Courbe f\")\n",
" ax.plot(x, x, label=\"$y=x$\")\n",
" ax.scatter([i for i in x if f(i) == i], [f(i) for i in x if f(i) == i])\n",
" ax.legend()"
]
@@ -129,13 +129,13 @@
},
"outputs": [],
"source": [
"def point_fixe(f, x0, tol=1.e-6, itermax=5000):\n",
"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",
" \n",
"\n",
" Parameters\n",
" ----------\n",
" \n",
"\n",
" f: function\n",
" la fonction dont on cherche le point fixe\n",
" x0: float\n",
@@ -144,10 +144,10 @@
" critère d'arrêt : |x_{n+1} - x_n| < tol\n",
" itermax: int\n",
" le nombre maximal d'itérations autorisées\n",
" \n",
"\n",
" Returns\n",
" -------\n",
" \n",
"\n",
" x: float\n",
" la valeur trouvée pour le point fixe\n",
" niter: int\n",
@@ -225,14 +225,14 @@
"source": [
"# F1\n",
"\n",
"fig, ax = plt.subplots(figsize=(6,6))\n",
"fig, ax = plt.subplots(figsize=(6, 6))\n",
"\n",
"x, niter, xL = point_fixe(f1, -0.5)\n",
"xx = np.linspace(-1, 1, 200)\n",
"\n",
"ax.plot(xx, f1(xx), label='Courbe f1')\n",
"ax.plot(xx, xx, label=f'$y=x$')\n",
"ax.scatter(x, f1(x), label='Point Fixe')\n",
"ax.plot(xx, f1(xx), label=\"Courbe f1\")\n",
"ax.plot(xx, xx, label=\"$y=x$\")\n",
"ax.scatter(x, f1(x), label=\"Point Fixe\")\n",
"ax.legend()\n",
"ax.set_title(f\"Nombre d'itérations : {niter}\")"
]

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

@@ -103,38 +103,45 @@
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"# Fonction f définissant l'EDO\n",
"def f1(t,y):\n",
" return -t*y\n",
"\n",
"# Solution exacte \n",
"def uex1(t,y0):\n",
" return y0 * np.exp(-t**2 /2)\n",
"# Fonction f définissant l'EDO\n",
"def f1(t, y):\n",
" return -t * y\n",
"\n",
"\n",
"# Solution exacte\n",
"def uex1(t, y0):\n",
" return y0 * np.exp(-(t**2) / 2)\n",
"\n",
"\n",
"plt.figure(1)\n",
"\n",
"## Solutions de l'EDO 1 telles que y(0)=1 et y(0)=2\n",
"\n",
"tt=np.linspace(-3, 3, 100) # vecteur représentant l'intervalle de temps\n",
"y1=uex1(tt, 1) # sol. exacte avec y_0=1\n",
"y2=uex1(tt, 2) # sol. exacte avec y_0=2\n",
"plt.plot(tt,y1,label='y(0)=1')\n",
"plt.plot(tt,y2,label='y(0)=2')\n",
"tt = np.linspace(-3, 3, 100) # vecteur représentant l'intervalle de temps\n",
"y1 = uex1(tt, 1) # sol. exacte avec y_0=1\n",
"y2 = uex1(tt, 2) # sol. exacte avec y_0=2\n",
"plt.plot(tt, y1, label=\"y(0)=1\")\n",
"plt.plot(tt, y2, label=\"y(0)=2\")\n",
"\n",
"##Tracé du champ de vecteurs\n",
"\n",
"plt.title('Solution exacte pour y0 et y1')\n",
"plt.title(\"Solution exacte pour y0 et y1\")\n",
"plt.legend()\n",
"plt.xlabel('t')\n",
"plt.ylabel('y')\n",
"plt.xlabel(\"t\")\n",
"plt.ylabel(\"y\")\n",
"\n",
"t=np.linspace(-5,5,35) # abcisse des points de la grille \n",
"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(1+f1(T,Y)**2) # matrice avec les composantes horizontales des vecteurs (1), normalisées \n",
"V=f1(T,Y)/np.sqrt(1+f1(T,Y)**2) # 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])"
"t = np.linspace(-5, 5, 35) # abcisse des points de la grille\n",
"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",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = f1(T, Y) / np.sqrt(\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])"
]
},
{
@@ -185,40 +192,47 @@
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"# Fonction f définissant l'EDO\n",
"def f2(t,y):\n",
"def f2(t, y):\n",
" return t * y**2\n",
"\n",
"# Solution exacte \n",
"def uex2(t,y0):\n",
"\n",
"# Solution exacte\n",
"def uex2(t, y0):\n",
" return y0 / (1 - y0 * t**2 / 2)\n",
"\n",
"\n",
"plt.figure(1)\n",
"\n",
"## Solutions de l'EDO 1 telles que y(0)=1 et y(0)=2\n",
"\n",
"tt=np.linspace(-3, 3, 100) # vecteur représentant l'intervalle de temps\n",
"y1=uex2(tt, 1) # sol. exacte avec y_0=1\n",
"y2=uex2(tt, 2) # sol. exacte avec y_0=2\n",
"plt.plot(tt,y1,label='y(0)=1')\n",
"plt.plot(tt,y2,label='y(0)=2')\n",
"tt = np.linspace(-3, 3, 100) # vecteur représentant l'intervalle de temps\n",
"y1 = uex2(tt, 1) # sol. exacte avec y_0=1\n",
"y2 = uex2(tt, 2) # sol. exacte avec y_0=2\n",
"plt.plot(tt, y1, label=\"y(0)=1\")\n",
"plt.plot(tt, y2, label=\"y(0)=2\")\n",
"\n",
"##Tracé du champ de vecteurs\n",
"\n",
"plt.title('Solution exacte pour y0 et y1')\n",
"plt.title(\"Solution exacte pour y0 et y1\")\n",
"plt.legend()\n",
"plt.xlabel('t')\n",
"plt.ylabel('y')\n",
"plt.xlabel(\"t\")\n",
"plt.ylabel(\"y\")\n",
"\n",
"xmin, xmax = -2, 2\n",
"ymin, ymax = -4, 4\n",
"\n",
"t=np.linspace(xmin, xmax,35) # abcisse des points de la grille \n",
"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(1+f2(T,Y)**2) # matrice avec les composantes horizontales des vecteurs (1), normalisées \n",
"V=f1(T,Y)/np.sqrt(1+f2(T,Y)**2) # 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",
"t = np.linspace(xmin, xmax, 35) # abcisse des points de la grille\n",
"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",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = f1(T, Y) / np.sqrt(\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])"
]
},
@@ -339,33 +353,34 @@
],
"source": [
"# Euler explicite\n",
"def euler_exp(t0,T,y0,h,f):\n",
" t = np.arange(t0, t0+T+h, h)\n",
"def euler_exp(t0, T, y0, h, f):\n",
" t = np.arange(t0, t0 + T + h, h)\n",
" y = np.empty(t.size)\n",
" y[0] = y0\n",
" N = len(t)-1\n",
" N = len(t) - 1\n",
" for n in range(N):\n",
" y[n+1] = y[n] + h * f(t[n], y[n])\n",
" y[n + 1] = y[n] + h * f(t[n], y[n])\n",
" return t, y\n",
"\n",
"t0=0\n",
"T=1\n",
"y0=1\n",
"\n",
"t0 = 0\n",
"T = 1\n",
"y0 = 1\n",
"\n",
"for f, uex in zip([f1, f2], [uex1, uex2]):\n",
" plt.figure()\n",
" t = np.arange(0, 1, 1e-3)\n",
" y = uex(t, y0)\n",
" plt.plot(t, y, label='Solution exacte')\n",
" plt.plot(t, y, label=\"Solution exacte\")\n",
"\n",
" for h in [1/5, 1/10, 1/50]:\n",
" for h in [1 / 5, 1 / 10, 1 / 50]:\n",
" tt, y = euler_exp(t0, T, y0, h, f)\n",
" plt.plot(tt, y, label=f'Solution approchée pour h={h}')\n",
" \n",
" plt.plot(tt, y, label=f\"Solution approchée pour h={h}\")\n",
"\n",
" plt.title(f\"Solutions exacte et approchées de la fonction {f.__name__}\")\n",
" plt.legend()\n",
" plt.xlabel('t')\n",
" plt.ylabel('y')"
" plt.xlabel(\"t\")\n",
" plt.ylabel(\"y\")"
]
},
{
@@ -441,12 +456,14 @@
],
"source": [
"# Modèle de Verhulst\n",
"n=1\n",
"d=0.75\n",
"K=200\n",
"n = 1\n",
"d = 0.75\n",
"K = 200\n",
"\n",
"\n",
"def fV(t, P):\n",
" return (n - d) * P * (1 - P / K)\n",
"\n",
"def fV(t,P):\n",
" return (n-d)*P*(1-P/K)\n",
"\n",
"plt.figure()\n",
"\n",
@@ -455,20 +472,24 @@
"t0, T = 0, 50\n",
"\n",
"\n",
"for P in range(1, K+100, 15):\n",
"for P in range(1, K + 100, 15):\n",
" tt, yy = euler_exp(t0, T, P, h, fV)\n",
" plt.plot(tt, yy, label=f'Solution approchée pour h={h}')\n",
" \n",
"plt.title(f\"Solution approchée du modèle de Verhulst pour la population d'individus\")\n",
"plt.xlabel('t')\n",
"plt.ylabel('y')\n",
" plt.plot(tt, yy, label=f\"Solution approchée pour h={h}\")\n",
"\n",
"t=np.linspace(t0, T, 35) # abcisse des points de la grille \n",
"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(1+fV(T,P)**2) # matrice avec les composantes horizontales des vecteurs (1), normalisées \n",
"V=fV(T,P)/np.sqrt(1+fV(T,P)**2) # 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.title(\"Solution approchée du modèle de Verhulst pour la population d'individus\")\n",
"plt.xlabel(\"t\")\n",
"plt.ylabel(\"y\")\n",
"\n",
"t = np.linspace(t0, T, 35) # abcisse des points de la grille\n",
"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",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = fV(T, P) / np.sqrt(\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)"
]
},
@@ -527,29 +548,34 @@
}
],
"source": [
"def fS(t,P):\n",
" return (2-np.cos(t))*P-(P**2)/2-1\n",
"def fS(t, P):\n",
" return (2 - np.cos(t)) * P - (P**2) / 2 - 1\n",
"\n",
"P0=5\n",
"t0=0\n",
"T=10\n",
"h=0.1\n",
"\n",
"P0 = 5\n",
"t0 = 0\n",
"T = 10\n",
"h = 0.1\n",
"\n",
"plt.figure()\n",
"tt, yy = euler_exp(t0, T, P0, h, fS)\n",
"plt.plot(tt, yy, label=f'Solution approchée pour h={h}')\n",
" \n",
"plt.title(f\"Solutions approchée du modèle de Verhulst pour une population de saumons\")\n",
"plt.legend()\n",
"plt.xlabel('t')\n",
"plt.ylabel('y')\n",
"plt.plot(tt, yy, label=f\"Solution approchée pour h={h}\")\n",
"\n",
"t=np.linspace(t0, T, 35) # abcisse des points de la grille \n",
"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(1+fS(T,P)**2) # matrice avec les composantes horizontales des vecteurs (1), normalisées \n",
"V=fS(T,P)/np.sqrt(1+fS(T,P)**2) # 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.title(\"Solutions approchée du modèle de Verhulst pour une population de saumons\")\n",
"plt.legend()\n",
"plt.xlabel(\"t\")\n",
"plt.ylabel(\"y\")\n",
"\n",
"t = np.linspace(t0, T, 35) # abcisse des points de la grille\n",
"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",
") # matrice avec les composantes horizontales des vecteurs (1), normalisées\n",
"V = fS(T, P) / np.sqrt(\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\")"
]
},
{

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

@@ -95,53 +95,63 @@
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"# Fonction F définissant l'EDO\n",
"def F(Y):\n",
" x=Y[0]\n",
" y=Y[1]\n",
" A=np.array([[0,1],[-2,-3]])\n",
" return np.dot(A,Y)\n",
" x = Y[0]\n",
" y = Y[1]\n",
" A = np.array([[0, 1], [-2, -3]])\n",
" return np.dot(A, Y)\n",
"\n",
"# ou \n",
"def F1(x,y):\n",
"\n",
"# ou\n",
"def F1(x, y):\n",
" return y\n",
"\n",
"def F2(x,y):\n",
" return -2*x-3*y\n",
"\n",
"def F2(x, y):\n",
" return -2 * x - 3 * y\n",
"\n",
"\n",
"# Solution exacte de Y'=AY, Y(t_0)=Y_0\n",
"def uex(t,t0,Y0):\n",
" U1=np.array([1,-1])\n",
" U2=np.array([1,-2])\n",
" P=np.ones((2,2))\n",
" P[:,0]=U1\n",
" P[:,1]=U2\n",
" C=np.linalg.solve(P,Y0)\n",
" return np.array([(C[0]*np.exp(-(t-t0))*U1[0]+C[1]*np.exp(-2*(t-t0))*U2[0]),(C[0]*np.exp(-(t-t0))*U1[1]+C[1]*np.exp(-2*(t-t0))*U2[1])])\n",
"def uex(t, t0, Y0):\n",
" U1 = np.array([1, -1])\n",
" U2 = np.array([1, -2])\n",
" P = np.ones((2, 2))\n",
" P[:, 0] = U1\n",
" P[:, 1] = U2\n",
" C = np.linalg.solve(P, Y0)\n",
" return np.array(\n",
" [\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",
"## Représentation des solutions pour chaque valeur de la donnée initiale \n",
"\n",
"## Représentation des solutions pour chaque valeur de la donnée initiale\n",
"tt = np.linspace(-10, 10, 100)\n",
"t0 = tt[0]\n",
"for x, y in zip([1, -2, 0, 1, 3], [2, -2, -4, -2, 4]):\n",
" sol = uex(tt, t0, [x, y])\n",
" plt.plot(sol[0], sol[1], label=f'$((x0, y0) = ({x}, {y})$')\n",
" plt.plot(sol[0], sol[1], label=f\"$((x0, y0) = ({x}, {y})$\")\n",
" plt.scatter(x, y)\n",
"\n",
"#Tracé du champ de vecteurs\n",
"x=np.linspace(-5,5,26)\n",
"y=x\n",
"xx,yy=np.meshgrid(x,y)\n",
"U=F1(xx,yy)/np.sqrt(F1(xx,yy)**2+F2(xx,yy)**2)\n",
"V=F2(xx,yy)/np.sqrt(F1(xx,yy)**2+F2(xx,yy)**2)\n",
"plt.quiver(xx,yy,U,V,angles='xy', scale=20, color='gray')\n",
"plt.axis([-5.,5,-5,5])\n",
"# Tracé du champ de vecteurs\n",
"x = np.linspace(-5, 5, 26)\n",
"y = x\n",
"xx, yy = np.meshgrid(x, y)\n",
"U = F1(xx, yy) / np.sqrt(F1(xx, yy) ** 2 + F2(xx, yy) ** 2)\n",
"V = F2(xx, yy) / np.sqrt(F1(xx, yy) ** 2 + F2(xx, yy) ** 2)\n",
"plt.quiver(xx, yy, U, V, angles=\"xy\", scale=20, color=\"gray\")\n",
"plt.axis([-5.0, 5, -5, 5])\n",
"\n",
"## Représentation des espaces propres \n",
"plt.plot(tt, -tt, label=f'SEP associé à -1', linewidth=3)\n",
"plt.plot(tt, -2*tt, label=f'SEP associé à -2', linewidth=3)\n",
"## Représentation des espaces propres\n",
"plt.plot(tt, -tt, label=\"SEP associé à -1\", linewidth=3)\n",
"plt.plot(tt, -2 * tt, label=\"SEP associé à -2\", linewidth=3)\n",
"\n",
"plt.legend(fontsize=7)\n",
"plt.title('Représentation des solutions et champs de vecteurs pour le système (S)')"
"plt.title(\"Représentation des solutions et champs de vecteurs pour le système (S)\")"
]
},
{
@@ -210,13 +220,15 @@
"source": [
"a, b, c, d = 0.1, 5e-5, 0.04, 5e-5\n",
"H0, P0 = 2000, 1000\n",
"He, Pe = c/d, a/b\n",
"He, Pe = c / d, a / b\n",
"\n",
"\n",
"def F1(H, P):\n",
" return H * (a - b*P)\n",
" return H * (a - b * P)\n",
"\n",
"\n",
"def F2(H, P):\n",
" return P * (-c + d*H)"
" return P * (-c + d * H)"
]
},
{
@@ -256,17 +268,17 @@
}
],
"source": [
"xx, yy = np.linspace(0, 3000, 20), np.linspace (0, 4500, 30)\n",
"h,p = np.meshgrid(xx, yy)\n",
"n=np.sqrt(F1(h,p)**2+F2(h,p)**2)\n",
"plt.quiver(h, p, F1(h,p)/n, F2(h,p)/n, angles='xy', scale=20, color='gray')\n",
"xx, yy = np.linspace(0, 3000, 20), np.linspace(0, 4500, 30)\n",
"h, p = np.meshgrid(xx, yy)\n",
"n = np.sqrt(F1(h, p) ** 2 + F2(h, p) ** 2)\n",
"plt.quiver(h, p, F1(h, p) / n, F2(h, p) / n, angles=\"xy\", scale=20, color=\"gray\")\n",
"\n",
"plt.vlines(He, 0, 4500, label=f'H=He={He}')\n",
"plt.hlines(Pe, 0, 3000, label=f'P=Pe={Pe}')\n",
"plt.scatter(He, Pe, label=f'(H0, P0) = (He, Pe)')\n",
"plt.scatter(H0, P0, label=f'(H, P)=(H0, P0)=({H0},{P0})', color='red')\n",
"plt.vlines(He, 0, 4500, label=f\"H=He={He}\")\n",
"plt.hlines(Pe, 0, 3000, label=f\"P=Pe={Pe}\")\n",
"plt.scatter(He, Pe, label=\"(H0, P0) = (He, Pe)\")\n",
"plt.scatter(H0, P0, label=f\"(H, P)=(H0, P0)=({H0},{P0})\", color=\"red\")\n",
"\n",
"plt.title('Le modèle de Lotka-Volterra')\n",
"plt.title(\"Le modèle de Lotka-Volterra\")\n",
"plt.legend(fontsize=7)"
]
},
@@ -374,19 +386,20 @@
"outputs": [],
"source": [
"a, b, c, d = 0.1, 5e-5, 0.04, 5e-5\n",
"T=200\n",
"T = 200\n",
"H0, P0 = 2000, 1000\n",
"He, Pe = c/d, a/b\n",
"p=0.02\n",
"He, Pe = c / d, a / b\n",
"p = 0.02\n",
"\n",
"\n",
"def voltEE(T, X0, h):\n",
" t = np.arange(0, T+h, h)\n",
" t = np.arange(0, T + h, h)\n",
" H = 0 * t\n",
" P = 0 * t\n",
" H[0], P[0] = X0\n",
" for n in range(len(t)-1):\n",
" H[n+1] = H[n] + h * F1(H[n], P[n])\n",
" P[n+1] = P[n] + h * F2(H[n], P[n])\n",
" for n in range(len(t) - 1):\n",
" H[n + 1] = H[n] + h * F1(H[n], P[n])\n",
" P[n + 1] = P[n] + h * F2(H[n], P[n])\n",
" return np.array([t, H, P])"
]
},
@@ -438,22 +451,22 @@
],
"source": [
"t, H, P = voltEE(T, [H0, P0], 0.001)\n",
"plt.plot(t, H, label='Population de sardines')\n",
"plt.plot(t, P, label='Population de requins')\n",
"plt.plot(t, H, label=\"Population de sardines\")\n",
"plt.plot(t, P, label=\"Population de requins\")\n",
"plt.legend(fontsize=7)\n",
"\n",
"plt.figure()\n",
"xx, yy = np.linspace(0, 3000, 20), np.linspace (0, 4500, 30)\n",
"h,p = np.meshgrid(xx, yy)\n",
"n=np.sqrt(F1(h,p)**2 + F2(h,p)**2)\n",
"plt.quiver (h, p, F1(h,p)/n, F2(h,p)/n, angles='xy', scale=20, color='gray')\n",
"xx, yy = np.linspace(0, 3000, 20), np.linspace(0, 4500, 30)\n",
"h, p = np.meshgrid(xx, yy)\n",
"n = np.sqrt(F1(h, p) ** 2 + F2(h, p) ** 2)\n",
"plt.quiver(h, p, F1(h, p) / n, F2(h, p) / n, angles=\"xy\", scale=20, color=\"gray\")\n",
"\n",
"plt.vlines(He, 0, 4500, label=f'H=He={He}')\n",
"plt.hlines(Pe, 0, 3000, label=f'P=Pe={Pe}')\n",
"plt.scatter(He, Pe, label=f'(H0, P0) = (He, Pe)')\n",
"plt.scatter(H0, P0, label=f'(H, P)=(H0, P0)=({H0},{P0})', color='red')\n",
"plt.vlines(He, 0, 4500, label=f\"H=He={He}\")\n",
"plt.hlines(Pe, 0, 3000, label=f\"P=Pe={Pe}\")\n",
"plt.scatter(He, Pe, label=\"(H0, P0) = (He, Pe)\")\n",
"plt.scatter(H0, P0, label=f\"(H, P)=(H0, P0)=({H0},{P0})\", color=\"red\")\n",
"\n",
"plt.title('Le modèle de Lotka-Volterra')\n",
"plt.title(\"Le modèle de Lotka-Volterra\")\n",
"plt.legend(fontsize=7)\n",
"plt.plot(H, P)"
]
@@ -467,25 +480,28 @@
"outputs": [],
"source": [
"a, b, c, d = 0.1, 5e-5, 0.04, 5e-5\n",
"T=200\n",
"T = 200\n",
"H0, P0 = 2000, 1000\n",
"He, Pe = c/d, a/b\n",
"p=0.02\n",
"He, Pe = c / d, a / b\n",
"p = 0.02\n",
"\n",
"\n",
"def F1_p(H, P):\n",
" return (a - p) * H - b * H * P\n",
"\n",
"\n",
"def F2_p(H, P):\n",
" return (-c-p) * P + d * H * P\n",
" return (-c - p) * P + d * H * P\n",
"\n",
"\n",
"def voltEE_p(T, X0, h):\n",
" t = np.arange(0, T+h, h)\n",
" t = np.arange(0, T + h, h)\n",
" H = 0 * t\n",
" P = 0 * t\n",
" H[0], P[0] = X0\n",
" for n in range(len(t)-1):\n",
" H[n+1] = H[n] + h * F1_p(H[n], P[n])\n",
" P[n+1] = P[n] + h * F2_p(H[n], P[n])\n",
" for n in range(len(t) - 1):\n",
" H[n + 1] = H[n] + h * F1_p(H[n], P[n])\n",
" P[n + 1] = P[n] + h * F2_p(H[n], P[n])\n",
" return np.array([t, H, P])"
]
},
@@ -535,22 +551,22 @@
],
"source": [
"t, H, P = voltEE_p(T, [H0, P0], 0.001)\n",
"plt.plot(t, H, label='Population de sardines')\n",
"plt.plot(t, P, label='Population de requins')\n",
"plt.plot(t, H, label=\"Population de sardines\")\n",
"plt.plot(t, P, label=\"Population de requins\")\n",
"plt.legend(fontsize=7)\n",
"\n",
"plt.figure()\n",
"xx, yy = np.linspace(0, 3000, 20), np.linspace (0, 4500, 30)\n",
"h,p = np.meshgrid(xx, yy)\n",
"n=np.sqrt(F1(h,p)**2 + F2(h,p)**2)\n",
"plt.quiver (h, p, F1(h,p)/n, F2(h,p)/n, angles='xy', scale=20, color='gray')\n",
"xx, yy = np.linspace(0, 3000, 20), np.linspace(0, 4500, 30)\n",
"h, p = np.meshgrid(xx, yy)\n",
"n = np.sqrt(F1(h, p) ** 2 + F2(h, p) ** 2)\n",
"plt.quiver(h, p, F1(h, p) / n, F2(h, p) / n, angles=\"xy\", scale=20, color=\"gray\")\n",
"\n",
"plt.vlines(He, 0, 4500, label=f'H=He={He}')\n",
"plt.hlines(Pe, 0, 3000, label=f'P=Pe={Pe}')\n",
"plt.scatter(He, Pe, label=f'(H0, P0) = (He, Pe)')\n",
"plt.scatter(H0, P0, label=f'(H, P)=(H0, P0)=({H0},{P0})', color='red')\n",
"plt.vlines(He, 0, 4500, label=f\"H=He={He}\")\n",
"plt.hlines(Pe, 0, 3000, label=f\"P=Pe={Pe}\")\n",
"plt.scatter(He, Pe, label=\"(H0, P0) = (He, Pe)\")\n",
"plt.scatter(H0, P0, label=f\"(H, P)=(H0, P0)=({H0},{P0})\", color=\"red\")\n",
"\n",
"plt.title('Le modèle de Lotka-Volterra')\n",
"plt.title(\"Le modèle de Lotka-Volterra\")\n",
"plt.legend(fontsize=7)\n",
"plt.plot(H, P)"
]
@@ -697,46 +713,49 @@
}
],
"source": [
"gamma=0.5\n",
"a=0.004\n",
"lm=10\n",
"gamma = 0.5\n",
"a = 0.004\n",
"lm = 10\n",
"\n",
"\n",
"def fphi(d):\n",
" return (gamma/d)*np.log(d/a)\n",
" return (gamma / d) * np.log(d / a)\n",
"\n",
"\n",
"def F(X):\n",
" (n,m)=np.shape(X)\n",
" Y=np.zeros((n,m))\n",
" Y[0,:]=X[1,:]\n",
" Xaux=np.zeros(m+2)\n",
" Xaux[-1]=1\n",
" Xaux[1:-1]=X[0,:]\n",
" Y[1,:]=fphi(Xaux[2:]-Xaux[1:-1])-fphi(Xaux[1:-1]-Xaux[0:-2])-lm*X[1,:]\n",
" (n, m) = np.shape(X)\n",
" Y = np.zeros((n, m))\n",
" Y[0, :] = X[1, :]\n",
" Xaux = np.zeros(m + 2)\n",
" Xaux[-1] = 1\n",
" Xaux[1:-1] = X[0, :]\n",
" Y[1, :] = fphi(Xaux[2:] - Xaux[1:-1]) - fphi(Xaux[1:-1] - Xaux[0:-2]) - lm * X[1, :]\n",
" return Y\n",
"\n",
"h=0.0002\n",
"T=15\n",
"N=100\n",
"\n",
"t=np.arange(0,T+h,h)\n",
"Nt=np.size(t)\n",
"X=np.zeros((2,N,Nt))\n",
"R0=-1+2*np.random.rand(N)\n",
"X0=np.arange(1/(N+1),1,1/(N+1))+0.1*R0*(1/(N+1))\n",
"h = 0.0002\n",
"T = 15\n",
"N = 100\n",
"\n",
"X[0,:,0]=X0\n",
"X[1,:,0]=X0\n",
"t = np.arange(0, T + h, h)\n",
"Nt = np.size(t)\n",
"X = np.zeros((2, N, Nt))\n",
"R0 = -1 + 2 * np.random.rand(N)\n",
"X0 = np.arange(1 / (N + 1), 1, 1 / (N + 1)) + 0.1 * R0 * (1 / (N + 1))\n",
"\n",
"X[0, :, 0] = X0\n",
"X[1, :, 0] = X0\n",
"\n",
"plt.figure(1, figsize=(24, 18))\n",
"for n in range(Nt - 1):\n",
" Y = F(X[:, :, n])\n",
" X[:, :, n + 1] = X[:, :, n] + (h / 2) * Y + (h / 2) * F(X[:, :, n] + h * Y)\n",
"\n",
"plt.figure(1,figsize=(24,18))\n",
"for n in range(Nt-1):\n",
" Y=F(X[:,:,n])\n",
" X[:,:,n+1]=X[:,:,n]+(h/2)*Y+(h/2)*F(X[:,:,n]+h*Y)\n",
" \n",
"for i in range(N):\n",
" plt.plot(t,X[0,i,:],'k')\n",
"plt.xlabel('t')\n",
"plt.ylabel('$x_i$')\n",
"plt.title('position x_i des globules rouges au cours du temps')\n"
" plt.plot(t, X[0, i, :], \"k\")\n",
"plt.xlabel(\"t\")\n",
"plt.ylabel(\"$x_i$\")\n",
"plt.title(\"position x_i des globules rouges au cours du temps\")"
]
},
{

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

@@ -76,14 +76,15 @@
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"## Question 1\n",
"def mon_schema(t0, T, y0, h, f):\n",
" t = np.arange(t0, t0 + T + h, h)\n",
" y = 0 * t\n",
" y[0] = y0\n",
" for n in range(len(t)-1):\n",
" yn1 = y[n] + h * f(t[n] + h / 2, y[n] + h/2 * f(t[n], y[n]))\n",
" y[n+1] = y[n] + h / 2 * (f(t[n], y[n]) + f(t[n+1], yn1))\n",
" for n in range(len(t) - 1):\n",
" yn1 = y[n] + h * f(t[n] + h / 2, y[n] + h / 2 * f(t[n], y[n]))\n",
" y[n + 1] = y[n] + h / 2 * (f(t[n], y[n]) + f(t[n + 1], yn1))\n",
" return t, y"
]
},
@@ -140,25 +141,27 @@
"## Question 2\n",
"\n",
"# f second membre de l'EDO\n",
"def f(t,y):\n",
"def f(t, y):\n",
" return y + np.sin(t) * np.power(y, 2)\n",
"\n",
"\n",
"# sol. exacte de (P)\n",
"def yex(t):\n",
" return 1 / (1/2 * np.exp(-t) + (np.cos(t)-np.sin(t)) / 2)\n",
" return 1 / (1 / 2 * np.exp(-t) + (np.cos(t) - np.sin(t)) / 2)\n",
"\n",
"\n",
"t0, T = 0, 0.5\n",
"N = 100\n",
"y0 = 1\n",
"t, y_app = mon_schema(t0, T, y0, T/N, f)\n",
"t, y_app = mon_schema(t0, T, y0, T / N, f)\n",
"y_ex = yex(t)\n",
"\n",
"plt.figure(1)\n",
"plt.plot(t, y_ex, label='Solution exacte', lw=3)\n",
"plt.plot(t, y_app, '+ ', label=f'Solution approchée pour N={N}')\n",
"plt.title('Solutions approchées pour mon_schema')\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel(f'$y$')\n",
"plt.plot(t, y_ex, label=\"Solution exacte\", lw=3)\n",
"plt.plot(t, y_app, \"+ \", label=f\"Solution approchée pour N={N}\")\n",
"plt.title(\"Solutions approchées pour mon_schema\")\n",
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$y$\")\n",
"plt.legend(fontsize=7)"
]
},
@@ -212,15 +215,17 @@
"# Question 3\n",
"plt.figure(2)\n",
"\n",
"for s in range(2,11):\n",
" h=(1/2)/(2**s)\n",
"for s in range(2, 11):\n",
" h = (1 / 2) / (2**s)\n",
" t, y_app = mon_schema(t0, T, y0, h, f)\n",
" plt.plot(t, y_app, label=f'h={h}')\n",
" plt.plot(t, y_app, label=f\"h={h}\")\n",
"\n",
"plt.legend(fontsize=7)\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel('$y^n$')\n",
"plt.title('Solutions approchées de (P) obtenus avec mon_schema pour différentes valeurs du pas h')"
"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",
")"
]
},
{
@@ -252,23 +257,25 @@
}
],
"source": [
"E=[]\n",
"H=[]\n",
"E = []\n",
"H = []\n",
"\n",
"plt.figure(3)\n",
"for s in range(2,11):\n",
" h=(1/2)/(2**s)\n",
"for s in range(2, 11):\n",
" h = (1 / 2) / (2**s)\n",
" t, y_app = mon_schema(t0, T, y0, h, f)\n",
" y_ex = yex(t)\n",
" err = np.max(np.abs(y_app - y_ex))\n",
" plt.plot(t, np.abs(y_app - y_ex), label=f'h={h}')\n",
" plt.plot(t, np.abs(y_app - y_ex), label=f\"h={h}\")\n",
" E.append(err)\n",
" H.append(h)\n",
" \n",
"\n",
"plt.legend()\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel('$|y(t_n) - y^n|$')\n",
"plt.title('différence en valeur absolue entre sol. exacte et sol. approchée par mon_schema, pour différentes valeurs du pas h')"
"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",
")"
]
},
{
@@ -304,13 +311,13 @@
"\n",
"H, E = np.array(H), np.array(E)\n",
"\n",
"plt.plot(T/H, E/H, label=f'$E_h / h$')\n",
"plt.plot(T/H, E/H**2, label=f'$E_h / h^2$')\n",
"plt.plot(T / H, E / H, label=\"$E_h / h$\")\n",
"plt.plot(T / H, E / H**2, label=\"$E_h / h^2$\")\n",
"\n",
"plt.legend()\n",
"plt.xlabel('N')\n",
"plt.ylabel('Erreur globale')\n",
"plt.title('Erreur globale en fonction de N')"
"plt.xlabel(\"N\")\n",
"plt.ylabel(\"Erreur globale\")\n",
"plt.title(\"Erreur globale en fonction de N\")"
]
},
{
@@ -344,14 +351,16 @@
"source": [
"plt.figure(5)\n",
"\n",
"plt.plot(np.log(H), np.log(E), '+-', label='erreur')\n",
"plt.plot(np.log(H), np.log(H), '-', label='droite pente 1')\n",
"plt.plot(np.log(H), 2*np.log(H), '-', label='droite pente 2')\n",
"plt.plot(np.log(H), np.log(E), \"+-\", label=\"erreur\")\n",
"plt.plot(np.log(H), np.log(H), \"-\", label=\"droite pente 1\")\n",
"plt.plot(np.log(H), 2 * np.log(H), \"-\", label=\"droite pente 2\")\n",
"\n",
"plt.legend()\n",
"plt.title('Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)')\n",
"plt.xlabel(f'$log(h)$')\n",
"plt.ylabel(f'$log(E)$')"
"plt.title(\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)$\")"
]
},
{
@@ -444,24 +453,26 @@
" t = np.arange(t0, t0 + T + h, h)\n",
" y = 0 * t\n",
" y[0] = y0\n",
" for n in range(len(t)-1):\n",
" y[n+1] = y[n] + h * f(t[n+1], y[n+1])\n",
" for n in range(len(t) - 1):\n",
" y[n + 1] = y[n] + h * f(t[n + 1], y[n + 1])\n",
" return t, y\n",
"\n",
"\n",
"def crank(t0, T, y0, h, f):\n",
" t = np.arange(t0, t0 + T + h, h)\n",
" y = 0 * t\n",
" y[0] = y0\n",
" for n in range(len(t)-1):\n",
" y[n+1] = y[n] + h/2 * (f(t[n], y[n]) + f(t[n+1], y[n+1]))\n",
" for n in range(len(t) - 1):\n",
" y[n + 1] = y[n] + h / 2 * (f(t[n], y[n]) + f(t[n + 1], y[n + 1]))\n",
" return t, y\n",
"\n",
"\n",
"def adams(t0, T, y0, h, f):\n",
" t = np.arange(t0, t0 + T + h, h)\n",
" y = 0 * t\n",
" y[0] = y0\n",
" for n in range(1, len(t)-1):\n",
" y[n+1] = y[n] + h/2 * (3* f(t[n], y[n]) - f(t[n-1], y[n-1]))\n",
" for n in range(1, len(t) - 1):\n",
" y[n + 1] = y[n] + h / 2 * (3 * f(t[n], y[n]) - f(t[n - 1], y[n - 1]))\n",
" return t, y"
]
},
@@ -474,39 +485,41 @@
"outputs": [],
"source": [
"def euler_explicite(t0, T, y0, h, f):\n",
" N = int(T/h)\n",
" N = int(T / h)\n",
" n = len(y0)\n",
" t = np.linspace(t0, t0 + T, N+1)\n",
" y = np.zeros((N+1, n))\n",
" t = np.linspace(t0, t0 + T, N + 1)\n",
" y = np.zeros((N + 1, n))\n",
" y[0,] = y0\n",
" for n in range(N):\n",
" y[n+1] = y[n] + h * f(t[n], y[n])\n",
" y[n + 1] = y[n] + h * f(t[n], y[n])\n",
" return t, y\n",
"\n",
"\n",
"def heun(t0, T, y0, h, f):\n",
" N = int(T/h)\n",
" N = int(T / h)\n",
" n = len(y0)\n",
" t = np.linspace(t0, t0 + T, N+1)\n",
" y = np.zeros((N+1, n))\n",
" t = np.linspace(t0, t0 + T, N + 1)\n",
" y = np.zeros((N + 1, n))\n",
" y[0,] = y0\n",
" for n in range(N):\n",
" p1 = f(t[n], y[n])\n",
" p2 = f(t[n] + h, y[n] + h * p1)\n",
" y[n+1] = y[n] + h/2 * (p1 + p2)\n",
" y[n + 1] = y[n] + h / 2 * (p1 + p2)\n",
" return t, y\n",
"\n",
"\n",
"def runge(t0, T, y0, h, f):\n",
" N = int(T/h)\n",
" N = int(T / h)\n",
" n = len(y0)\n",
" t = np.linspace(t0, t0 + T, N+1)\n",
" y = np.zeros((N+1, n))\n",
" t = np.linspace(t0, t0 + T, N + 1)\n",
" y = np.zeros((N + 1, n))\n",
" y[0,] = y0\n",
" for n in range(N):\n",
" p1 = f(t[n], y[n])\n",
" p2 = f(t[n] + h/2, y[n] + h/2 * p1)\n",
" p3 = f(t[n] + h/2, y[n] + h/2 * p2)\n",
" p4 = f(t[n] + h, y[n] + h* p3)\n",
" y[n+1] = y[n] + h/6 * (p1 + 2*p2 + 2*p3 + p4)\n",
" p2 = f(t[n] + h / 2, y[n] + h / 2 * p1)\n",
" p3 = f(t[n] + h / 2, y[n] + h / 2 * p2)\n",
" p4 = f(t[n] + h, y[n] + h * p3)\n",
" y[n + 1] = y[n] + h / 6 * (p1 + 2 * p2 + 2 * p3 + p4)\n",
" return t, y"
]
},
@@ -624,13 +637,16 @@
"# Question 1\n",
"a, b, c = 0.1, 2, 1\n",
"\n",
"\n",
"# f second membre de l'EDO\n",
"def f1(t,y):\n",
" return c * y * (1 - y/b)\n",
"def f1(t, y):\n",
" return c * y * (1 - y / b)\n",
"\n",
"\n",
"# sol. exacte de (P1)\n",
"def yex1(t):\n",
" return b / (1 + (b-a)/a * np.exp(-c*t))\n",
" return b / (1 + (b - a) / a * np.exp(-c * t))\n",
"\n",
"\n",
"t0, T = 0, 15\n",
"h = 0.2\n",
@@ -639,25 +655,27 @@
"plt.figure()\n",
"for schema in [euler_explicite, heun, runge]:\n",
" t, y_app = schema(t0, T, y0, h, f1)\n",
" plt.plot(t, y_app.ravel(), '+ ', label=f'Solution approchée par {schema.__name__}')\n",
" plt.plot(t, y_app.ravel(), \"+ \", label=f\"Solution approchée par {schema.__name__}\")\n",
"\n",
"t = np.arange(t0, t0+T+h, h)\n",
"t = np.arange(t0, t0 + T + h, h)\n",
"y_ex = yex1(t)\n",
"plt.plot(t, y_ex, label='Solution exacte', lw=1)\n",
"plt.title(f'Solutions approchées pour le schema {schema.__name__}')\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel(f'$y$')\n",
"plt.plot(t, y_ex, label=\"Solution exacte\", lw=1)\n",
"plt.title(f\"Solutions approchées pour le schema {schema.__name__}\")\n",
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$y$\")\n",
"plt.legend(fontsize=7)\n",
"\n",
"plt.figure()\n",
"for schema in [euler_explicite, heun, runge]: \n",
"for schema in [euler_explicite, heun, runge]:\n",
" t, y_app = schema(t0, T, y0, h, f1)\n",
" plt.plot(t, np.abs(y_app.ravel() - yex1(t)), label=f'Schema {schema.__name__}')\n",
" \n",
" plt.plot(t, np.abs(y_app.ravel() - yex1(t)), label=f\"Schema {schema.__name__}\")\n",
"\n",
"plt.legend()\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel('$|y(t_n) - y^n|$')\n",
"plt.title(f'différence en valeur absolue entre sol. exacte et sol. approchée, pour différents schemas')"
"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",
")"
]
},
{
@@ -696,24 +714,26 @@
" Z[1] = -Y[0] + np.cos(t)\n",
" return Z\n",
"\n",
"\n",
"def yexF(t):\n",
" return 1/2 * np.sin(t) * t + 5 * np.cos(t) + np.sin(t),\n",
" return (1 / 2 * np.sin(t) * t + 5 * np.cos(t) + np.sin(t),)\n",
"\n",
"\n",
"t0, T = 0, 15\n",
"h = 0.2\n",
"Y0 = np.array([5,1])\n",
"Y0 = np.array([5, 1])\n",
"\n",
"plt.figure()\n",
"for schema in [euler_explicite, heun, runge]:\n",
" t, y_app = schema(t0, T, Y0, h, F)\n",
" plt.plot(t, y_app[:,0], '+ ', label=f'Solution approchée par {schema.__name__}')\n",
" plt.plot(t, y_app[:, 0], \"+ \", label=f\"Solution approchée par {schema.__name__}\")\n",
"\n",
"t = np.arange(t0, t0+T+h, h)\n",
"t = np.arange(t0, t0 + T + h, h)\n",
"y_ex = yexF(t)\n",
"plt.plot(t, y_ex[0], label='Solution exacte', lw=3)\n",
"plt.title('Solutions approchées par differents schemas')\n",
"plt.xlabel(f'$t$')\n",
"plt.ylabel(f'$y$')\n",
"plt.plot(t, y_ex[0], label=\"Solution exacte\", lw=3)\n",
"plt.title(\"Solutions approchées par differents schemas\")\n",
"plt.xlabel(\"$t$\")\n",
"plt.ylabel(\"$y$\")\n",
"plt.legend(fontsize=7)"
]
},
@@ -730,16 +750,19 @@
"import matplotlib.pyplot as plt\n",
"# Question 3\n",
"\n",
"\n",
"# f second membre de l'EDO\n",
"def f3(t,y):\n",
" return (np.cos(t) - y) / (1+t)\n",
"def f3(t, y):\n",
" return (np.cos(t) - y) / (1 + t)\n",
"\n",
"\n",
"# sol. exacte de (P1)\n",
"def yex3(t):\n",
" return (np.sin(t) - 1/4) / (1 + t)\n",
" return (np.sin(t) - 1 / 4) / (1 + t)\n",
"\n",
"\n",
"t0, T = 0, 10\n",
"y0 = np.array([-1/4])"
"y0 = np.array([-1 / 4])"
]
},
{
@@ -793,15 +816,17 @@
"plt.figure()\n",
"for schema in [euler_explicite, heun, runge]:\n",
" plt.figure()\n",
" for s in range(2,11):\n",
" h=1/(2**s)\n",
" for s in range(2, 11):\n",
" h = 1 / (2**s)\n",
" t, y_app = schema(t0, T, y0, h, f3)\n",
" plt.plot(t, y_app, label=f'h={h}')\n",
" plt.plot(t, y_app, label=f\"h={h}\")\n",
"\n",
" plt.legend(fontsize=7)\n",
" plt.xlabel(f'$t$')\n",
" plt.ylabel('$y^n$')\n",
" plt.title(f'Solutions approchées de (P) obtenus avec {schema.__name__} pour différentes valeurs du pas h')"
" 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",
" )"
]
},
{
@@ -846,22 +871,24 @@
"for schema in [euler_explicite, heun, runge]:\n",
" H, E = [], []\n",
" plt.figure()\n",
" for s in range(2,11):\n",
" h=1/(2**s)\n",
" for s in range(2, 11):\n",
" h = 1 / (2**s)\n",
" t, y_app = schema(t0, T, y0, h, f3)\n",
" E.append(np.max(np.abs(yex3(t) - y_app.ravel())))\n",
" H.append(h)\n",
" \n",
"\n",
" H, E = np.array(H), np.array(E)\n",
" plt.plot(np.log(H), np.log(E), '+-', label='erreur')\n",
" plt.plot(np.log(H), np.log(H), '-', label='droite pente 1')\n",
" plt.plot(np.log(H), 2*np.log(H), '-', label='droite pente 2')\n",
" plt.plot(np.log(H), 3*np.log(H), '-', label='droite pente 3')\n",
" \n",
" plt.plot(np.log(H), np.log(E), \"+-\", label=\"erreur\")\n",
" plt.plot(np.log(H), np.log(H), \"-\", label=\"droite pente 1\")\n",
" plt.plot(np.log(H), 2 * np.log(H), \"-\", label=\"droite pente 2\")\n",
" plt.plot(np.log(H), 3 * np.log(H), \"-\", label=\"droite pente 3\")\n",
"\n",
" plt.legend()\n",
" plt.title(f'Erreur pour la méthode {schema.__name__} en echelle logarithmique : log(E) en fonction de log(h)')\n",
" plt.xlabel(f'$log(h)$')\n",
" plt.ylabel(f'$log(E)$')"
" plt.title(\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)$\")"
]
},
{
@@ -943,19 +970,20 @@
"a = 5\n",
"t0, T = 0, 20\n",
"H = [0.1, 0.05, 0.025]\n",
"Y0 = np.array([1/10, 1])\n",
"Y0 = np.array([1 / 10, 1])\n",
"\n",
"\n",
"def P(t, Y):\n",
" return np.array([Y[1], (a - Y[0]**2) * Y[1] - Y[0]])\n",
" return np.array([Y[1], (a - Y[0] ** 2) * Y[1] - Y[0]])\n",
"\n",
"\n",
"for schema in [euler_explicite, heun, runge]:\n",
" plt.figure()\n",
" for h in H:\n",
" t, y_app = schema(t0, T, Y0, h, P)\n",
" plt.plot(t, y_app[:,0], '+ ', label=f'Solution approchée pour h={h}')\n",
" plt.plot(t, y_app[:, 0], \"+ \", label=f\"Solution approchée pour h={h}\")\n",
" plt.legend()\n",
" plt.title(f'Solutions approchees pour differents pas h par {schema.__name__}')\n",
" "
" plt.title(f\"Solutions approchees pour differents pas h par {schema.__name__}\")"
]
},
{

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

@@ -240,22 +240,25 @@
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"%matplotlib inline\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def A(M):\n",
" return 2 * np.eye(M) - np.eye(M, k=-1) - np.eye(M, k=1)\n",
"\n",
"\n",
"def solution_approchée(f, M, a=0, b=1, ua=0, ub=0):\n",
" X = np.linspace(a, b + 1 if b == 0 else b, M+2)\n",
" U = np.zeros(M+2)\n",
" X = np.linspace(a, b + 1 if b == 0 else b, M + 2)\n",
" U = np.zeros(M + 2)\n",
" U[0], U[-1] = ua, ub\n",
" \n",
" h = (b-a)/(M+1)\n",
"\n",
" h = (b - a) / (M + 1)\n",
"\n",
" delta = np.zeros(M)\n",
" delta[0], delta[-1] = ua/np.power(h, 2), ub/np.power(h, 2)\n",
" \n",
" delta[0], delta[-1] = ua / np.power(h, 2), ub / np.power(h, 2)\n",
"\n",
" U[1:-1] = np.linalg.solve(A(M), h**2 * (f(X)[1:-1] + delta))\n",
" return X, U"
]
@@ -290,22 +293,25 @@
],
"source": [
"M = 50\n",
"h = 1/(M+1)\n",
"h = 1 / (M + 1)\n",
"\n",
"\n",
"def f1(x):\n",
" return (2 * np.pi)**2 * np.sin(2 * np.pi * x)\n",
" return (2 * np.pi) ** 2 * np.sin(2 * np.pi * x)\n",
"\n",
"\n",
"def u1(x):\n",
" return np.sin(2 * np.pi * x)\n",
"\n",
"\n",
"x, U_app = solution_approchée(f1, M)\n",
"plt.figure()\n",
"plt.scatter(x, U_app, label=f\"$A_M U_h = h² F$\")\n",
"plt.plot(x, u1(x), label='Solution exacte', color='red')\n",
"plt.scatter(x, U_app, label=\"$A_M U_h = h² F$\")\n",
"plt.plot(x, u1(x), label=\"Solution exacte\", color=\"red\")\n",
"plt.legend()\n",
"plt.ylabel('f(x)')\n",
"plt.xlabel('x')\n",
"plt.title(f\"$-u''=f(x)$\")"
"plt.ylabel(\"f(x)\")\n",
"plt.xlabel(\"x\")\n",
"plt.title(\"$-u''=f(x)$\")"
]
},
{
@@ -340,21 +346,23 @@
"H, E = [], []\n",
"for k in range(2, 12):\n",
" M = 2**k\n",
" h = 1/(M+1)\n",
" \n",
" h = 1 / (M + 1)\n",
"\n",
" x, U_app = solution_approchée(f1, M)\n",
" \n",
"\n",
" e = np.abs(u1(x) - U_app)\n",
" plt.plot(x, e, label=f'{h}')\n",
" plt.plot(x, e, label=f\"{h}\")\n",
" E.append(np.max(e))\n",
" H.append(h)\n",
"\n",
"H, E = np.array(H), np.array(E) \n",
"H, E = np.array(H), np.array(E)\n",
"\n",
"plt.xlabel('$h$')\n",
"plt.ylabel('$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$')\n",
"plt.xlabel(\"$h$\")\n",
"plt.ylabel(\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title('Différence en valeur absolue entre la solution exacte et la solution approchée')"
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
")"
]
},
{
@@ -387,12 +395,12 @@
],
"source": [
"plt.figure()\n",
"plt.plot(H, E/H, label=f'$E_h / h$')\n",
"plt.plot(H, E/H**2, label=f'$E_h / h^2$')\n",
"plt.plot(H, E / H, label=\"$E_h / h$\")\n",
"plt.plot(H, E / H**2, label=\"$E_h / h^2$\")\n",
"plt.legend()\n",
"plt.xlabel('$h$')\n",
"plt.ylabel('Erreur globale')\n",
"plt.title('Erreur globale en fonction de $h$')"
"plt.xlabel(\"$h$\")\n",
"plt.ylabel(\"Erreur globale\")\n",
"plt.title(\"Erreur globale en fonction de $h$\")"
]
},
{
@@ -425,13 +433,15 @@
],
"source": [
"plt.figure()\n",
"plt.plot(np.log(H), np.log(E), '+-', label='erreur')\n",
"plt.plot(np.log(H), np.log(H), '-', label='droite pente 1')\n",
"plt.plot(np.log(H), 2*np.log(H), '-', label='droite pente 2')\n",
"plt.plot(np.log(H), np.log(E), \"+-\", label=\"erreur\")\n",
"plt.plot(np.log(H), np.log(H), \"-\", label=\"droite pente 1\")\n",
"plt.plot(np.log(H), 2 * np.log(H), \"-\", label=\"droite pente 2\")\n",
"plt.legend()\n",
"plt.xlabel(f'$log(h)$')\n",
"plt.ylabel(f'$log(E)$')\n",
"plt.title('Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)')"
"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",
")"
]
},
{
@@ -509,27 +519,31 @@
],
"source": [
"import numpy as np\n",
"\n",
"%matplotlib inline\n",
"import matplotlib.pyplot as plt\n",
"\n",
"ua, ub = 1/2, 1/3\n",
"ua, ub = 1 / 2, 1 / 3\n",
"a, b = 1, 2\n",
"M = 49\n",
"\n",
"\n",
"def f2(x):\n",
" return -2/np.power((x+1), 3)\n",
" return -2 / np.power((x + 1), 3)\n",
"\n",
"\n",
"def u2(x):\n",
" return 1/(x+1)\n",
" return 1 / (x + 1)\n",
"\n",
"\n",
"x, U_app = solution_approchée(f2, M, a, b, ua, ub)\n",
"plt.figure()\n",
"plt.scatter(x, U_app, label=f\"$A_M U_h = h² F$\")\n",
"plt.plot(x, u2(x), label='Solution exacte', color='red')\n",
"plt.scatter(x, U_app, label=\"$A_M U_h = h² F$\")\n",
"plt.plot(x, u2(x), label=\"Solution exacte\", color=\"red\")\n",
"plt.legend()\n",
"plt.ylabel('f(x)')\n",
"plt.xlabel('x')\n",
"plt.title(f\"$-u''=f(x)$\")"
"plt.ylabel(\"f(x)\")\n",
"plt.xlabel(\"x\")\n",
"plt.title(\"$-u''=f(x)$\")"
]
},
{
@@ -565,19 +579,21 @@
"H, E = [], []\n",
"for k in range(2, 12):\n",
" M = 2**k\n",
" h = (b-a)/(M+1)\n",
" \n",
" h = (b - a) / (M + 1)\n",
"\n",
" x, U_app = solution_approchée(f2, M, a, b, ua, ub)\n",
" \n",
"\n",
" e = np.abs(u2(x) - U_app)\n",
" plt.plot(x, e, label=f'{h}')\n",
" plt.plot(x, e, label=f\"{h}\")\n",
" E.append(np.max(e))\n",
" H.append(h)\n",
" \n",
"plt.xlabel('$h$')\n",
"plt.ylabel('$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$')\n",
"\n",
"plt.xlabel(\"$h$\")\n",
"plt.ylabel(\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title('Différence en valeur absolue entre la solution exacte et la solution approchée')"
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
")"
]
},
{
@@ -609,14 +625,14 @@
}
],
"source": [
"H, E = np.array(H), np.array(E) \n",
"H, E = np.array(H), np.array(E)\n",
"plt.figure()\n",
"plt.plot(H, E/H, label=f'$E_h / h$')\n",
"plt.plot(H, E/H**2, label=f'$E_h / h^2$')\n",
"plt.plot(H, E / H, label=\"$E_h / h$\")\n",
"plt.plot(H, E / H**2, label=\"$E_h / h^2$\")\n",
"plt.legend()\n",
"plt.xlabel('$h$')\n",
"plt.ylabel('Erreur globale')\n",
"plt.title('Erreur globale en fonction de $h$')"
"plt.xlabel(\"$h$\")\n",
"plt.ylabel(\"Erreur globale\")\n",
"plt.title(\"Erreur globale en fonction de $h$\")"
]
},
{
@@ -649,13 +665,15 @@
],
"source": [
"plt.figure()\n",
"plt.plot(np.log(H), np.log(E), '+-', label='erreur')\n",
"plt.plot(np.log(H), np.log(H), '-', label='droite pente 1')\n",
"plt.plot(np.log(H), 2*np.log(H), '-', label='droite pente 2')\n",
"plt.plot(np.log(H), np.log(E), \"+-\", label=\"erreur\")\n",
"plt.plot(np.log(H), np.log(H), \"-\", label=\"droite pente 1\")\n",
"plt.plot(np.log(H), 2 * np.log(H), \"-\", label=\"droite pente 2\")\n",
"plt.legend()\n",
"plt.xlabel(f'$log(h)$')\n",
"plt.ylabel(f'$log(E)$')\n",
"plt.title('Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)')"
"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",
")"
]
},
{
@@ -732,22 +750,25 @@
],
"source": [
"def An(M, h):\n",
" mat = 2*np.eye(M) - np.eye(M, k=1) - np.eye(M, k=-1)\n",
" mat[0,0] = 1\n",
" mat = 2 * np.eye(M) - np.eye(M, k=1) - np.eye(M, k=-1)\n",
" mat[0, 0] = 1\n",
" mat[-1, -1] = 1\n",
" return mat + h**2 * np.eye(M)\n",
"\n",
"\n",
"def f3(x):\n",
" return (np.power(2 * np.pi, 2) + 1 ) * np.cos(2*np.pi * x)\n",
" return (np.power(2 * np.pi, 2) + 1) * np.cos(2 * np.pi * x)\n",
"\n",
"\n",
"def u3(x):\n",
" return np.cos(2*np.pi * x)\n",
" return np.cos(2 * np.pi * x)\n",
"\n",
"\n",
"def solution_neumann(f, M, a, b):\n",
" X = np.linspace(a, b, M+2)\n",
" U = np.zeros(M+2)\n",
" h = 1/(M+1)\n",
" \n",
" X = np.linspace(a, b, M + 2)\n",
" U = np.zeros(M + 2)\n",
" h = 1 / (M + 1)\n",
"\n",
" U[1:-1] = np.linalg.solve(An(M, h), h**2 * f3(X[1:-1]))\n",
" U[0], U[-1] = U[1], U[-2]\n",
" return X, U\n",
@@ -759,12 +780,14 @@
"for M in [49, 99, 499]:\n",
" x, U_app = solution_neumann(f3, M, a, b)\n",
"\n",
" plt.scatter(x, U_app, marker='+', s=3, label=\"$h^2({A_N}_h + I_M)U = h^2F$ pour M={M}\")\n",
"plt.plot(x, u3(x), label='Solution exacte', color='red')\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",
" )\n",
"plt.plot(x, u3(x), label=\"Solution exacte\", color=\"red\")\n",
"plt.legend(fontsize=8)\n",
"plt.ylabel('f(x)')\n",
"plt.xlabel('x')\n",
"plt.title(f\"$-u''(x) + u(x)=f(x)$\")"
"plt.ylabel(\"f(x)\")\n",
"plt.xlabel(\"x\")\n",
"plt.title(\"$-u''(x) + u(x)=f(x)$\")"
]
},
{
@@ -800,19 +823,21 @@
"H, E = [], []\n",
"for k in range(2, 12):\n",
" M = 2**k\n",
" h = (b-a)/(M+1)\n",
" \n",
" h = (b - a) / (M + 1)\n",
"\n",
" x, U_app = solution_neumann(f3, M, a, b)\n",
" \n",
"\n",
" e = np.abs(u3(x) - U_app)\n",
" plt.plot(x, e, label=f'{h}')\n",
" plt.plot(x, e, label=f\"{h}\")\n",
" E.append(np.max(e))\n",
" H.append(h)\n",
" \n",
"plt.xlabel('$h$')\n",
"plt.ylabel('$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$')\n",
"\n",
"plt.xlabel(\"$h$\")\n",
"plt.ylabel(\"$\\max_{j=0,\\dots,M+1}|u(x_j)-u_j|$\")\n",
"plt.legend(fontsize=7)\n",
"plt.title('Différence en valeur absolue entre la solution exacte et la solution approchée')"
"plt.title(\n",
" \"Différence en valeur absolue entre la solution exacte et la solution approchée\"\n",
")"
]
},
{
@@ -845,13 +870,15 @@
],
"source": [
"plt.figure()\n",
"plt.plot(np.log(H), np.log(E), '+-', label='erreur')\n",
"plt.plot(np.log(H), np.log(H), '-', label='droite pente 1')\n",
"plt.plot(np.log(H), 2*np.log(H), '-', label='droite pente 2')\n",
"plt.plot(np.log(H), np.log(E), \"+-\", label=\"erreur\")\n",
"plt.plot(np.log(H), np.log(H), \"-\", label=\"droite pente 1\")\n",
"plt.plot(np.log(H), 2 * np.log(H), \"-\", label=\"droite pente 2\")\n",
"plt.legend()\n",
"plt.xlabel(f'$log(h)$')\n",
"plt.ylabel(f'$log(E)$')\n",
"plt.title('Erreur pour la méthode mon_schema en echelle logarithmique : log(E) en fonction de log(h)')"
"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",
")"
]
},
{
@@ -959,7 +986,11 @@
"outputs": [],
"source": [
"def v(x):\n",
" return 4*np.exp(-500*np.square(x-.8)) + np.exp(-50*np.square(x-.2))+.5*np.random.random(x.shape)"
" return (\n",
" 4 * np.exp(-500 * np.square(x - 0.8))\n",
" + np.exp(-50 * np.square(x - 0.2))\n",
" + 0.5 * np.random.random(x.shape)\n",
" )"
]
}
],

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

File diff suppressed because one or more lines are too long

54
L3/Statistiques/TP1.ipynb
View File

@@ -48,10 +48,10 @@
"nb_repl = 100000\n",
"sample = np.random.exponential(lam, nb_repl)\n",
"intervalle = np.linspace(0, 5, 100)\n",
"plt.hist(sample, bins=intervalle, density=True, label='Echantillon')\n",
"plt.hist(sample, bins=intervalle, density=True, label=\"Echantillon\")\n",
"\n",
"densite = stats.expon().pdf\n",
"plt.plot(intervalle, densite(intervalle), label='Fonction densité')\n",
"plt.plot(intervalle, densite(intervalle), label=\"Fonction densité\")\n",
"plt.legend()"
]
},
@@ -86,15 +86,15 @@
],
"source": [
"np_repl = 10000\n",
"sampleX, sampleY = 2*np.random.rand(np_repl)-1, 2*np.random.rand(np_repl)-1\n",
"sampleX, sampleY = 2 * np.random.rand(np_repl) - 1, 2 * np.random.rand(np_repl) - 1\n",
"\n",
"intervalle = np.linspace(-2, 2, 100)\n",
"plt.hist(sampleX + sampleY, bins=intervalle, density=True, label='Echantillon')\n",
"plt.hist(sampleX + sampleY, bins=intervalle, density=True, label=\"Echantillon\")\n",
"\n",
"densite = stats.uniform(-1, 2).pdf\n",
"plt.plot(intervalle, densite(intervalle), label='Fonction densité')\n",
"plt.plot(intervalle, densite(intervalle), label=\"Fonction densité\")\n",
"\n",
"plt.plot(intervalle, 1/4 * np.maximum(2 - np.abs(intervalle), 0), label='Fonction')\n",
"plt.plot(intervalle, 1 / 4 * np.maximum(2 - np.abs(intervalle), 0), label=\"Fonction\")\n",
"plt.legend()"
]
},
@@ -130,10 +130,22 @@
"source": [
"lam = 1\n",
"nb_repl = 10000\n",
"sampleX, sampleY, sampleZ = np.random.exponential(lam, nb_repl), np.random.exponential(lam, nb_repl), np.random.exponential(lam, nb_repl)\n",
"sampleX, sampleY, sampleZ = (\n",
" np.random.exponential(lam, nb_repl),\n",
" np.random.exponential(lam, nb_repl),\n",
" np.random.exponential(lam, nb_repl),\n",
")\n",
"intervalle = np.linspace(-5, 5, 100)\n",
"plt.hist(sampleX - sampleY/2, bins=intervalle, density=True, alpha=.7, label='Echantillon de X - Y/2')\n",
"plt.hist(sampleZ/2, bins=intervalle, density=True, alpha=.7, label='Echantillon de Z')\n",
"plt.hist(\n",
" sampleX - sampleY / 2,\n",
" bins=intervalle,\n",
" density=True,\n",
" alpha=0.7,\n",
" 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",
")\n",
"plt.legend()"
]
},
@@ -157,15 +169,17 @@
}
],
"source": [
"p = 1/2\n",
"p = 1 / 2\n",
"nb_repl = 1000\n",
"\n",
"plt.figure(figsize=(18, 5))\n",
"for i, k in enumerate([10, 100, 1000]):\n",
" plt.subplot(1, 3, i+1)\n",
" plt.subplot(1, 3, i + 1)\n",
" sample = np.random.binomial(k, p, nb_repl)\n",
" intervalle = np.linspace(np.min(sample), np.max(sample), 100)\n",
" plt.hist(sample, bins=intervalle, density=True, label=f'Echantillon de X pour n={k}')\n",
" plt.hist(\n",
" sample, bins=intervalle, density=True, label=f\"Echantillon de X pour n={k}\"\n",
" )\n",
" plt.legend()"
]
},
@@ -179,7 +193,7 @@
"outputs": [],
"source": [
"def sample_uniforme(N):\n",
" return 2*np.random.rand(N) - 1"
" return 2 * np.random.rand(N) - 1"
]
},
{
@@ -218,7 +232,7 @@
"\n",
"for _ in range(nb_lgn):\n",
" liste_Sn.append(np.mean(sample_uniforme(nb_repl)))\n",
" \n",
"\n",
"nb_bins = 100\n",
"intervalles = np.linspace(np.min(liste_Sn), np.max(liste_Sn), nb_bins)\n",
"plt.hist(liste_Sn, density=True, bins=intervalles)\n",
@@ -256,12 +270,14 @@
"liste_Sn = []\n",
"\n",
"for _ in range(nb_lgn):\n",
" liste_Sn.append(np.mean(np.sqrt(3*nb_repl) * np.tan(np.pi/2 * sample_uniforme(nb_repl))))\n",
" liste_Sn.append(\n",
" np.mean(np.sqrt(3 * nb_repl) * np.tan(np.pi / 2 * sample_uniforme(nb_repl)))\n",
" )\n",
"\n",
"#nb_bins = 100\n",
"#intervalles = np.linspace(np.min(liste_Sn), np.max(liste_Sn), nb_bins)\n",
"#plt.hist(liste_Sn, density=True, bins=intervalles)\n",
"#plt.show()\n",
"# nb_bins = 100\n",
"# intervalles = np.linspace(np.min(liste_Sn), np.max(liste_Sn), nb_bins)\n",
"# plt.hist(liste_Sn, density=True, bins=intervalles)\n",
"# plt.show()\n",
"\n",
"plt.figure()\n",
"densite = stats.norm(scale=1).pdf\n",

47
L3/Statistiques/TP2.ipynb
View File

@@ -27,7 +27,12 @@
"source": [
"def f(L, z):\n",
" x, y = L[0], L[1]\n",
" return np.power(z*x, 2) + np.power(y/z, 2) - np.cos(2 * np.pi * x) - np.cos(2 * np.pi * y)"
" return (\n",
" np.power(z * x, 2)\n",
" + np.power(y / z, 2)\n",
" - np.cos(2 * np.pi * x)\n",
" - np.cos(2 * np.pi * y)\n",
" )"
]
},
{
@@ -123,17 +128,17 @@
"source": [
"plt.figure(figsize=(18, 5))\n",
"for i, nb_repl in enumerate([100, 1000, 10000]):\n",
" plt.subplot(1, 3, i+1)\n",
" plt.subplot(1, 3, i + 1)\n",
" sample_X1 = np.random.normal(0, 1, nb_repl)\n",
" sample_X2 = np.random.normal(3, np.sqrt(5), nb_repl)\n",
" sample_e = np.random.normal(0, np.sqrt(1/4), nb_repl)\n",
" sample_e = np.random.normal(0, np.sqrt(1 / 4), nb_repl)\n",
" Y = 5 * sample_X1 - 4 * sample_X2 + 2 + sample_e\n",
"\n",
" intervalle = np.linspace(np.min(Y), np.max(Y), 100)\n",
" plt.hist(Y, bins=intervalle, density=True, label='Echantillon de Y')\n",
" plt.hist(Y, bins=intervalle, density=True, label=\"Echantillon de Y\")\n",
"\n",
" densite = stats.norm(-10, np.sqrt(105.25)).pdf\n",
" plt.plot(intervalle, densite(intervalle), label='Fonction densité')\n",
" plt.plot(intervalle, densite(intervalle), label=\"Fonction densité\")\n",
"\n",
" plt.title(f\"Graphique de la somme de gaussiennes pour N={nb_repl}\")\n",
" plt.legend()"
@@ -151,8 +156,9 @@
"def theta_hat(Y):\n",
" return np.mean(Y)\n",
"\n",
"\n",
"def sigma_hat(Y):\n",
" return 1/nb_repl * np.sum(np.power(Y - theta_hat(Y), 2))"
" return 1 / nb_repl * np.sum(np.power(Y - theta_hat(Y), 2))"
]
},
{
@@ -166,7 +172,11 @@
"source": [
"def log_likehood_gauss(X, Y):\n",
" theta, sigma_2 = X[0], X[1]\n",
" return 1/2*np.log(2*np.pi) + 1/2*np.log(sigma_2) + 1/(2*nb_repl*sigma_2) * np.sum(np.power(Y - theta, 2))"
" return (\n",
" 1 / 2 * np.log(2 * np.pi)\n",
" + 1 / 2 * np.log(sigma_2)\n",
" + 1 / (2 * nb_repl * sigma_2) * np.sum(np.power(Y - theta, 2))\n",
" )"
]
},
{
@@ -191,9 +201,9 @@
"nb_repl = 5000\n",
"sample_X1 = np.random.normal(0, 1, nb_repl)\n",
"sample_X2 = np.random.normal(3, np.sqrt(5), nb_repl)\n",
"sample_e = np.random.normal(0, np.sqrt(1/4), nb_repl)\n",
"sample_e = np.random.normal(0, np.sqrt(1 / 4), nb_repl)\n",
"Y = 5 * sample_X1 - 4 * sample_X2 + 2 + sample_e\n",
" \n",
"\n",
"mk = {\"method\": \"BFGS\", \"args\": Y}\n",
"res = opt.basinhopping(log_likehood_gauss, x0=(-1, 98.75), minimizer_kwargs=mk)\n",
"print(res.x)\n",
@@ -211,12 +221,12 @@
"outputs": [],
"source": [
"def simule(a, b, n):\n",
" X = np.random.gamma(a, 1/b, n)\n",
" X = np.random.gamma(a, 1 / b, n)\n",
" intervalle = np.linspace(0, np.max(X), 100)\n",
" plt.hist(X, bins=intervalle, density=True, label='Echantillon de X')\n",
" plt.hist(X, bins=intervalle, density=True, label=\"Echantillon de X\")\n",
"\n",
" densite = stats.gamma.pdf(intervalle, a, 0, 1/b)\n",
" plt.plot(intervalle, densite, label='Fonction densité Gamma(2, 1)')\n",
" densite = stats.gamma.pdf(intervalle, a, 0, 1 / b)\n",
" plt.plot(intervalle, densite, label=\"Fonction densité Gamma(2, 1)\")\n",
" plt.legend()"
]
},
@@ -254,8 +264,13 @@
"source": [
"def log_likehood_gamma(X, sample):\n",
" a, b = X[0], X[1]\n",
" n = len(sample) \n",
" return -n*a*np.log(b) + n * np.log(sp.gamma(a)) - (a-1) * np.sum(np.log(sample)) + b * np.sum(sample)"
" n = len(sample)\n",
" return (\n",
" -n * a * np.log(b)\n",
" + n * np.log(sp.gamma(a))\n",
" - (a - 1) * np.sum(np.log(sample))\n",
" + b * np.sum(sample)\n",
" )"
]
},
{
@@ -296,7 +311,7 @@
"nb_repl = 1000\n",
"a, b = 2, 1\n",
"\n",
"sample = np.random.gamma(a, 1/b, nb_repl)\n",
"sample = np.random.gamma(a, 1 / b, nb_repl)\n",
"mk = {\"method\": \"BFGS\", \"args\": sample}\n",
"res = opt.basinhopping(log_likehood_gamma, x0=(1, 1), minimizer_kwargs=mk)\n",
"print(res.x)"

42
M1/Numerical Methods/TP1.ipynb
View File

@@ -122,7 +122,7 @@
" y = np.zeros(N + 1)\n",
" y[0] = y0\n",
" for n in range(N):\n",
" y[n + 1] = np.power(h + np.sqrt(h ** 2 + y[n]), 2)\n",
" y[n + 1] = np.power(h + np.sqrt(h**2 + y[n]), 2)\n",
" return t, y"
]
},
@@ -158,7 +158,7 @@
"\n",
"plt.scatter(t, sol_appr, label=\"Approximation with EI\")\n",
"plt.plot(x, f_exact(x, T), label=\"Exact solution\", color=\"red\")\n",
"plt.plot(x, x ** 2, label=\"Square function\", color=\"green\")\n",
"plt.plot(x, x**2, label=\"Square function\", color=\"green\")\n",
"plt.legend()\n",
"plt.show()"
]
@@ -297,9 +297,9 @@
"\n",
"sol = odeint(F, y0, t, args=(a, r))\n",
"\n",
"plt.plot(t, sol[:, 0], label='S(t)')\n",
"plt.plot(t, sol[:, 1], label='I(t)')\n",
"plt.plot(t, sol[:, 2], label='R(t)')\n",
"plt.plot(t, sol[:, 0], label=\"S(t)\")\n",
"plt.plot(t, sol[:, 1], label=\"I(t)\")\n",
"plt.plot(t, sol[:, 2], label=\"R(t)\")\n",
"plt.legend()\n",
"plt.show()"
]
@@ -336,7 +336,9 @@
"\n",
"def calculate_errors(sol_exact, sol_appr):\n",
" return np.max(\n",
" np.power(np.abs(sol_appr - sol_exact), 2)[np.isfinite(np.power(np.abs(sol_appr - sol_exact), 2))]\n",
" np.power(np.abs(sol_appr - sol_exact), 2)[\n",
" np.isfinite(np.power(np.abs(sol_appr - sol_exact), 2))\n",
" ]\n",
" )\n",
"\n",
"\n",
@@ -356,8 +358,8 @@
"plt.plot(errors_EE, label=\"Euler Explicit\")\n",
"plt.plot(errors_H, label=\"Heun\")\n",
"plt.plot(errors_RK4, label=\"Runge Kutta order 4\")\n",
"plt.yscale('log')\n",
"plt.xscale('log')\n",
"plt.yscale(\"log\")\n",
"plt.xscale(\"log\")\n",
"plt.legend()\n",
"plt.show()"
]
@@ -431,23 +433,23 @@
"# Plot the real parts\n",
"plt.figure(figsize=(12, 6))\n",
"plt.subplot(1, 2, 1)\n",
"plt.plot(t, np.real(x_appr_EI), label='Numerical Solution by EI')\n",
"plt.plot(t, np.real(x_appr_EE), label='Numerical Solution by EE')\n",
"plt.plot(t, np.real(x_exact), label='Exact Solution', linestyle='--')\n",
"plt.xlabel('Time')\n",
"plt.ylabel('Real Part')\n",
"plt.plot(t, np.real(x_appr_EI), label=\"Numerical Solution by EI\")\n",
"plt.plot(t, np.real(x_appr_EE), label=\"Numerical Solution by EE\")\n",
"plt.plot(t, np.real(x_exact), label=\"Exact Solution\", linestyle=\"--\")\n",
"plt.xlabel(\"Time\")\n",
"plt.ylabel(\"Real Part\")\n",
"plt.legend()\n",
"plt.title('Real Part of the Solution')\n",
"plt.title(\"Real Part of the Solution\")\n",
"\n",
"# Plot the imaginary parts\n",
"plt.subplot(1, 2, 2)\n",
"plt.plot(t, np.imag(x_appr_EI), label='Numerical Solution by EI')\n",
"plt.plot(t, np.imag(x_appr_EE), label='Numerical Solution by EE')\n",
"plt.plot(t, np.imag(x_exact), label='Exact Solution', linestyle='--')\n",
"plt.xlabel('Time')\n",
"plt.ylabel('Imaginary Part')\n",
"plt.plot(t, np.imag(x_appr_EI), label=\"Numerical Solution by EI\")\n",
"plt.plot(t, np.imag(x_appr_EE), label=\"Numerical Solution by EE\")\n",
"plt.plot(t, np.imag(x_exact), label=\"Exact Solution\", linestyle=\"--\")\n",
"plt.xlabel(\"Time\")\n",
"plt.ylabel(\"Imaginary Part\")\n",
"plt.legend()\n",
"plt.title('Imaginary Part of the Solution')\n",
"plt.title(\"Imaginary Part of the Solution\")\n",
"\n",
"plt.show()"
]

72
M1/Numerical Methods/TP2.ipynb
View File

@@ -1,8 +1,9 @@
{
"cells": [
{
"metadata": {},
"cell_type": "markdown",
"id": "c897654e0a140cbd",
"metadata": {},
"source": [
"# Automatic Differentiation\n",
"\n",
@@ -11,42 +12,18 @@
"Loss function: softmax layer in $\\mathbb{R}^3$\n",
"\n",
"Architecture: FC/ReLU 4-5-7-3"
],
"id": "c897654e0a140cbd"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "70a4eb1d928b10d0",
"metadata": {
"ExecuteTime": {
"end_time": "2025-03-24T15:16:27.015669Z",
"start_time": "2025-03-24T15:16:23.856887Z"
}
},
"cell_type": "code",
"source": [
"import numpy as np\n",
"from sklearn.neural_network import MLPClassifier\n",
"from sklearn.datasets import make_classification\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"accuracies = []\n",
"\n",
"for _ in range(10):\n",
" X, y = make_classification(n_samples=1000, n_features=4, n_classes=3, n_clusters_per_class=1)\n",
"\n",
" X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
" model = MLPClassifier(hidden_layer_sizes=(5, 7), activation='relu', max_iter=10000, solver='adam')\n",
" model.fit(X_train, y_train)\n",
"\n",
" y_pred = model.predict(X_test)\n",
" accuracies.append(accuracy_score(y_test, y_pred))\n",
"\n",
"print(f'Mean Accuracy: {np.mean(accuracies) * 100:.0f}%')\n",
"print(f'STD Accuracy: {np.std(accuracies) * 100:.0f}%')\n",
"print(f\"Max accuracy: {np.max(accuracies) * 100:.0f}%\")\n",
"print(f\"Min accuracy: {np.min(accuracies) * 100:.0f}%\")"
],
"id": "70a4eb1d928b10d0",
"outputs": [
{
"name": "stdout",
@@ -59,20 +36,47 @@
]
}
],
"execution_count": 33
"source": [
"import numpy as np\n",
"from sklearn.neural_network import MLPClassifier\n",
"from sklearn.datasets import make_classification\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"accuracies = []\n",
"\n",
"for _ in range(10):\n",
" X, y = make_classification(\n",
" n_samples=1000, n_features=4, n_classes=3, n_clusters_per_class=1\n",
" )\n",
"\n",
" X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
" model = MLPClassifier(\n",
" hidden_layer_sizes=(5, 7), activation=\"relu\", max_iter=10000, solver=\"adam\"\n",
" )\n",
" model.fit(X_train, y_train)\n",
"\n",
" y_pred = model.predict(X_test)\n",
" accuracies.append(accuracy_score(y_test, y_pred))\n",
"\n",
"print(f\"Mean Accuracy: {np.mean(accuracies) * 100:.0f}%\")\n",
"print(f\"STD Accuracy: {np.std(accuracies) * 100:.0f}%\")\n",
"print(f\"Max accuracy: {np.max(accuracies) * 100:.0f}%\")\n",
"print(f\"Min accuracy: {np.min(accuracies) * 100:.0f}%\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "96b6d46883ed5570",
"metadata": {
"ExecuteTime": {
"end_time": "2025-03-24T14:37:53.507776Z",
"start_time": "2025-03-24T14:37:53.505376Z"
}
},
"cell_type": "code",
"source": "",
"id": "96b6d46883ed5570",
"outputs": [],
"execution_count": null
"source": []
}
],
"metadata": {

144
M1/Numerical Methods/TP2_DANJOU_Arthur.ipynb
View File

@@ -51,17 +51,18 @@
" \"\"\"\n",
" return S0 * np.exp((mu - 0.5 * sigma**2) * t + sigma * W)\n",
"\n",
"\n",
"def euler_maruyama(mu, sigma, T, N, X0=0.0):\n",
" \"\"\"\n",
" Simulation d'une EDS de Black-Scholes par la méthode d'Euler-Maruyama\n",
" \n",
"\n",
" Paramètres :\n",
" mu (float) : drift\n",
" sigma (float) : volatilité\n",
" T (int) : temps final\n",
" N (int) : nombre de pas de temps\n",
" X0 (float) : valeur initiale\n",
" \n",
"\n",
" Retourne :\n",
" t (array-like) : tableau des temps\n",
" X (array-like) : tableau des valeurs de l'EDS\n",
@@ -70,17 +71,18 @@
"\n",
" t = np.linspace(0, T, N + 1)\n",
" X = np.zeros(N + 1)\n",
" \n",
"\n",
" X[0] = X0\n",
"\n",
" dW = np.random.normal(0, np.sqrt(dt), N)\n",
" \n",
"\n",
" for i in range(N):\n",
" St = S(t[i], X[i], mu, sigma, dW[i])\n",
" X[i + 1] = X[i] + mu * St * dt + sigma * St * dW[i]\n",
" \n",
"\n",
" return t, X\n",
"\n",
"\n",
"def plot_brownien(t, X, B=None):\n",
" \"\"\"\n",
" Plot la simulation d'Euler-Maruyama\n",
@@ -90,15 +92,15 @@
" X (array-like) : tableau des valeurs de l'EDS\n",
" B (float) : barrière (optionnelle)\n",
" \"\"\"\n",
" plt.plot(t, X, alpha=0.5, label='Euler-Maruyama')\n",
" plt.title('Simulation d\\'Euler-Maruyama pour une EDS')\n",
" \n",
" plt.plot(t, X, alpha=0.5, label=\"Euler-Maruyama\")\n",
" plt.title(\"Simulation d'Euler-Maruyama pour une EDS\")\n",
"\n",
" if B is not None:\n",
" plt.axhline(B, label='Barrière', color='red', linestyle='--')\n",
" \n",
" plt.axhline(B, label=\"Barrière\", color=\"red\", linestyle=\"--\")\n",
"\n",
" plt.legend()\n",
" plt.xlabel('Temps')\n",
" plt.ylabel('X(t)')\n",
" plt.xlabel(\"Temps\")\n",
" plt.ylabel(\"X(t)\")\n",
" plt.grid()"
]
},
@@ -165,10 +167,11 @@
"\n",
"np.random.seed(333)\n",
"\n",
"\n",
"def plot_convergence(S0, mu, sigma, T):\n",
" \"\"\"\n",
" Plot la convergence du schéma d'Euler-Maruyama\n",
" \n",
"\n",
" Paramètres :\n",
" S0 (int) : valeur initiale\n",
" mu (float) : drift\n",
@@ -176,26 +179,27 @@
" T (int) : temps final\n",
" \"\"\"\n",
" errors = []\n",
" \n",
"\n",
" for N in N_list:\n",
" dt = T / N\n",
" dW = np.random.normal(0, np.sqrt(dt), N)\n",
" \n",
"\n",
" exact = S(T, S0, mu, sigma, dW)\n",
" _, X = euler_maruyama(mu=mu, sigma=sigma, T=T, N=N, X0=S0)\n",
" \n",
"\n",
" errors.append(np.max(np.abs(X[1:] - exact)))\n",
" \n",
" plt.plot(np.log(h_list), np.log(errors), 'o-', label='Erreur numérique')\n",
" plt.plot(np.log(h_list), 0.5 * np.log(h_list), '--', label='Ordre 1/2')\n",
" plt.plot(np.log(h_list), np.log(h_list), '--', label='Ordre 1')\n",
" plt.plot(np.log(h_list), 2*np.log(h_list), '--', label='Ordre 2')\n",
" plt.xlabel('log(h)')\n",
" plt.ylabel('log(Erreur)')\n",
" plt.title('Convergence du schéma d\\'Euler-Maruyama')\n",
"\n",
" plt.plot(np.log(h_list), np.log(errors), \"o-\", label=\"Erreur numérique\")\n",
" plt.plot(np.log(h_list), 0.5 * np.log(h_list), \"--\", label=\"Ordre 1/2\")\n",
" plt.plot(np.log(h_list), np.log(h_list), \"--\", label=\"Ordre 1\")\n",
" plt.plot(np.log(h_list), 2 * np.log(h_list), \"--\", label=\"Ordre 2\")\n",
" plt.xlabel(\"log(h)\")\n",
" plt.ylabel(\"log(Erreur)\")\n",
" plt.title(\"Convergence du schéma d'Euler-Maruyama\")\n",
" plt.legend()\n",
" plt.grid(True)\n",
"\n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plot_convergence(S0, r, sigma, T)\n",
"plt.show()"
@@ -269,6 +273,7 @@
"plot_brownien(t, X, B=B)\n",
"plt.show()\n",
"\n",
"\n",
"def is_barrier_breached(X, B):\n",
" \"\"\"Renvoie True si la barrière est franchie, False sinon\n",
" La barrière est franchie si X >= B\n",
@@ -282,7 +287,12 @@
" \"\"\"\n",
" return any(X >= B)\n",
"\n",
"print(\"La barrière a été franchie\" if is_barrier_breached(X, B) else \"La barrière n'a pas été franchie\")"
"\n",
"print(\n",
" \"La barrière a été franchie\"\n",
" if is_barrier_breached(X, B)\n",
" else \"La barrière n'a pas été franchie\"\n",
")"
]
},
{
@@ -299,18 +309,19 @@
" trajectories (list of tuples): Liste des trajectoires avec le temps et les valeurs\n",
" B (float): Valeur de la barrière\n",
" \"\"\"\n",
" for (t, X) in trajectories:\n",
" col = 'pink' if is_barrier_breached(X, B) else 'lime'\n",
" for t, X in trajectories:\n",
" col = \"pink\" if is_barrier_breached(X, B) else \"lime\"\n",
" plt.plot(t, X, alpha=0.5, color=col)\n",
" plt.title('Simulation d\\'Euler-Maruyama pour une EDS')\n",
" \n",
" plt.axhline(B, label='Barrière', color='red', linestyle='--')\n",
" \n",
" plt.title(\"Simulation d'Euler-Maruyama pour une EDS\")\n",
"\n",
" plt.axhline(B, label=\"Barrière\", color=\"red\", linestyle=\"--\")\n",
"\n",
" plt.legend()\n",
" plt.xlabel('Temps')\n",
" plt.ylabel('X(t)')\n",
" plt.xlabel(\"Temps\")\n",
" plt.ylabel(\"X(t)\")\n",
" plt.grid()\n",
" \n",
"\n",
"\n",
"def payoff(X, B, K):\n",
" \"\"\"Calcule le payoff d'une option en fonction des trajectoires.\n",
"\n",
@@ -324,9 +335,10 @@
" \"\"\"\n",
" if not is_barrier_breached(X, B):\n",
" return max(X[-1] - K, 0)\n",
" else: \n",
" else:\n",
" return 0\n",
" \n",
"\n",
"\n",
"def call_BS(x):\n",
" \"\"\"Calcul du prix d'une option d'achat européenne selon le modèle de Black-Scholes en fonction de x.\n",
"\n",
@@ -336,27 +348,34 @@
" Retourne:\n",
" float: Le prix de l'option d'achat européenne.\n",
" \"\"\"\n",
" d1 = (np.log(x/K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))\n",
" d1 = (np.log(x / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))\n",
" d2 = d1 - sigma * np.sqrt(T)\n",
" return x * stats.norm.cdf(d1) - K * np.exp(-r * T) * stats.norm.cdf(d2)\n",
" \n",
"\n",
"\n",
"def compute_payoff_BS():\n",
" \"\"\"Calcul du prix d'une option d'achat Up-and-Out selon le modèle de Black-Scholes en fonction de la barrière.\n",
" \n",
"\n",
" Retourne:\n",
" float: Le prix de l'option d'achat Up-and-Out.\n",
" \"\"\"\n",
" lam = (r + 0.5 * sigma**2) / sigma**2\n",
" return call_BS(S0) - call_BS(S0) * (S0/B)**(2 * lam) + (S0/B)**(lam - 1) * (call_BS(B**2/S0) - (S0/B)**2 * call_BS(B**2/S0))\n",
" \n",
" return (\n",
" call_BS(S0)\n",
" - call_BS(S0) * (S0 / B) ** (2 * lam)\n",
" + (S0 / B) ** (lam - 1)\n",
" * (call_BS(B**2 / S0) - (S0 / B) ** 2 * call_BS(B**2 / S0))\n",
" )\n",
"\n",
"\n",
"def compute_payoff(trajectories, B, K):\n",
" \"\"\"Calcule le payoff d'une option en fonction des trajectoires.\n",
" \n",
"\n",
" Paramètres:\n",
" trajectories (list of tuples): Liste des trajectoires avec le temps et les valeurs.\n",
" B (float): Valeur de la barrière.\n",
" K (float): Prix d'exercice de l'option.\n",
" \n",
"\n",
" Retourne:\n",
" float: Valeur du payoff de l'option.\n",
" \"\"\"\n",
@@ -390,7 +409,13 @@
],
"source": [
"N_trajectories = 1000\n",
"trajectories = [(t, X) for (t, X) in [euler_maruyama(mu=r, sigma=sigma, T=T, N=1000, X0=S0) for _ in range(N_trajectories)]]\n",
"trajectories = [\n",
" (t, X)\n",
" for (t, X) in [\n",
" euler_maruyama(mu=r, sigma=sigma, T=T, N=1000, X0=S0)\n",
" for _ in range(N_trajectories)\n",
" ]\n",
"]\n",
"plt.figure(figsize=(10, 6))\n",
"plot_browniens(trajectories, B=B)\n",
"plt.show()\n",
@@ -431,28 +456,35 @@
"\n",
"np.random.seed(333)\n",
"\n",
"\n",
"def plot_payoff_errors():\n",
" \"\"\"Trace l'erreur de convergence du payoff actualisé en fonction de N.\"\"\"\n",
" errors = []\n",
" \n",
"\n",
" for N in N_list:\n",
" trajectories = [(t, X) for (t, X) in [euler_maruyama(mu=r, sigma=sigma, T=T, N=N, X0=S0) for _ in range(N_trajectories)]]\n",
" trajectories = [\n",
" (t, X)\n",
" for (t, X) in [\n",
" euler_maruyama(mu=r, sigma=sigma, T=T, N=N, X0=S0)\n",
" for _ in range(N_trajectories)\n",
" ]\n",
" ]\n",
" payoff_BS = compute_payoff_BS()\n",
" payoffs = compute_payoff(trajectories, B, K)\n",
" \n",
"\n",
" errors.append(np.max(np.abs(payoffs - payoff_BS)))\n",
" \n",
" \n",
" plt.plot(np.log(N_list), np.log(errors), 'o-', label='Erreur numérique')\n",
" plt.plot(np.log(N_list), 0.5 * np.log(N_list), '--', label='Ordre 1/2')\n",
" plt.plot(np.log(N_list), np.log(N_list), '--', label='Ordre 1')\n",
" plt.plot(np.log(N_list), 2*np.log(N_list), '--', label='Ordre 2')\n",
" plt.xlabel('log(h)')\n",
" plt.ylabel('log(Erreur)')\n",
" plt.title('Convergence de l\\'erreur du payoff actualisé')\n",
"\n",
" plt.plot(np.log(N_list), np.log(errors), \"o-\", label=\"Erreur numérique\")\n",
" plt.plot(np.log(N_list), 0.5 * np.log(N_list), \"--\", label=\"Ordre 1/2\")\n",
" plt.plot(np.log(N_list), np.log(N_list), \"--\", label=\"Ordre 1\")\n",
" plt.plot(np.log(N_list), 2 * np.log(N_list), \"--\", label=\"Ordre 2\")\n",
" plt.xlabel(\"log(h)\")\n",
" plt.ylabel(\"log(Erreur)\")\n",
" plt.title(\"Convergence de l'erreur du payoff actualisé\")\n",
" plt.legend()\n",
" plt.grid(True)\n",
"\n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plot_payoff_errors()\n",
"plt.show()"

127
M1/Numerical Methods/TP_DANJOU_Arthur.ipynb
View File

@@ -28,8 +28,9 @@
"k = np.arange(1, 12 + 1)\n",
"m = np.power(2, k)\n",
"\n",
"\n",
"def f(x):\n",
"\treturn 1 / np.sqrt(x)"
" return 1 / np.sqrt(x)"
]
},
{
@@ -39,19 +40,23 @@
"outputs": [],
"source": [
"a, b = 1, 2\n",
"\n",
"\n",
"def compute_I(f, a, b, m):\n",
" h_list = (b - a) / m\n",
" I = []\n",
" errors = []\n",
" sol_exact = quad(f, a, b)[0]\n",
" \n",
"\n",
" for h in h_list:\n",
" t = np.arange(a, b, h)\n",
" y = np.array([3/4 * h * f(t[i] + h/3) + h/4 * f(t[i] + h) for i in range(len(t))])\n",
" y = np.array(\n",
" [3 / 4 * h * f(t[i] + h / 3) + h / 4 * f(t[i] + h) for i in range(len(t))]\n",
" )\n",
" I_approx = np.sum(y)\n",
" I.append(I_approx)\n",
" errors.append(np.abs(I_approx - sol_exact))\n",
" \n",
"\n",
" return I, h_list, errors"
]
},
@@ -84,12 +89,12 @@
"print(f\"I1 = {I1}\")\n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plt.plot(np.log(h_list), np.log(errors1), 'o-', label='Erreur numérique')\n",
"plt.plot(np.log(h_list), 2*np.log(h_list), '--', label='Ordre 2')\n",
"plt.plot(np.log(h_list), 4*np.log(h_list), '--', label='Ordre 4')\n",
"plt.xlabel('log(h)')\n",
"plt.ylabel('log(Erreur)')\n",
"plt.title('Convergence de la méthode d\\'intégration')\n",
"plt.plot(np.log(h_list), np.log(errors1), \"o-\", label=\"Erreur numérique\")\n",
"plt.plot(np.log(h_list), 2 * np.log(h_list), \"--\", label=\"Ordre 2\")\n",
"plt.plot(np.log(h_list), 4 * np.log(h_list), \"--\", label=\"Ordre 4\")\n",
"plt.xlabel(\"log(h)\")\n",
"plt.ylabel(\"log(Erreur)\")\n",
"plt.title(\"Convergence de la méthode d'intégration\")\n",
"plt.legend()\n",
"plt.grid(True)\n",
"plt.show()"
@@ -116,12 +121,12 @@
"I2, h_list, errors2 = compute_I(f, a, b, m)\n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plt.plot(np.log(h_list), np.log(errors2), label='Approximation de l\\'intégrale')\n",
"plt.plot(np.log(h_list), np.log(h_list), '--', label='h')\n",
"plt.plot(np.log(h_list), 2*np.log(h_list), '--', label='h^2')\n",
"plt.xlabel('h')\n",
"plt.ylabel('Approximation de l\\'intégrale')\n",
"plt.title('Approximation de l\\'intégrale par la méthode de Simpson')\n",
"plt.plot(np.log(h_list), np.log(errors2), label=\"Approximation de l'intégrale\")\n",
"plt.plot(np.log(h_list), np.log(h_list), \"--\", label=\"h\")\n",
"plt.plot(np.log(h_list), 2 * np.log(h_list), \"--\", label=\"h^2\")\n",
"plt.xlabel(\"h\")\n",
"plt.ylabel(\"Approximation de l'intégrale\")\n",
"plt.title(\"Approximation de l'intégrale par la méthode de Simpson\")\n",
"plt.legend()\n",
"plt.show()"
]
@@ -146,19 +151,19 @@
"metadata": {},
"outputs": [],
"source": [
"def RKI(f, y0, vt, tol = 1e-6, itmax = 20):\n",
"\tN, T = len(vt), vt[-1]\n",
"\tyn = np.zeros((len(y0), N))\n",
"\tyn[:, 0] = y0\n",
"\th = T / N\n",
"def RKI(f, y0, vt, tol=1e-6, itmax=20):\n",
" N, T = len(vt), vt[-1]\n",
" yn = np.zeros((len(y0), N))\n",
" yn[:, 0] = y0\n",
" h = T / N\n",
"\n",
"\tfor n in range(N-1):\n",
"\t\tp1 = f(vt[n], yn[:, n])\n",
"\t\tF1 = lambda p2: f(vt[n] + h/3, yn[:, n] + h/6 * (p1 + p2)) - p2\n",
"\t\tp2 = newton(F1, yn[:, n], fprime=None, tol=tol, maxiter=itmax)\n",
"\t\tF2 = lambda yn1: yn[:, n] + h/4 * (3 * p2 + f(vt[n+1], yn1)) - yn1\n",
"\t\tyn[:, n + 1] = newton(F2, yn[:, n], fprime=None, tol=tol, maxiter=itmax)\n",
"\treturn yn"
" for n in range(N - 1):\n",
" p1 = f(vt[n], yn[:, n])\n",
" F1 = lambda p2: f(vt[n] + h / 3, yn[:, n] + h / 6 * (p1 + p2)) - p2\n",
" p2 = newton(F1, yn[:, n], fprime=None, tol=tol, maxiter=itmax)\n",
" F2 = lambda yn1: yn[:, n] + h / 4 * (3 * p2 + f(vt[n + 1], yn1)) - yn1\n",
" yn[:, n + 1] = newton(F2, yn[:, n], fprime=None, tol=tol, maxiter=itmax)\n",
" return yn"
]
},
{
@@ -194,14 +199,18 @@
"source": [
"a, b = [0, 2]\n",
"\n",
"\n",
"def f(t, y):\n",
" return t * np.power(y, 3) - t * y\n",
" \n",
"\n",
"\n",
"y0 = [0.5]\n",
"\n",
"\n",
"def sol_exact(t):\n",
" return 1 / np.sqrt(1 + 3 * np.exp(np.power(t, 2)))\n",
"\n",
"\n",
"x_fine = np.linspace(a, b, 1000)\n",
"y_fine = sol_exact(x_fine)\n",
"\n",
@@ -212,13 +221,13 @@
"y_exact_interp = np.interp(vt, x_fine, y_fine)\n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plt.plot(x_fine, y_fine, label='Solution exacte')\n",
"plt.scatter(vt, y, label='Solution numérique', color='red')\n",
"plt.plot(x_fine, y_fine, label=\"Solution exacte\")\n",
"plt.scatter(vt, y, label=\"Solution numérique\", color=\"red\")\n",
"plt.legend()\n",
"plt.show()\n",
"\n",
"error = np.max(np.abs(y - y_exact_interp))\n",
"print(f\"Error with h={h}: {error}\")\n"
"print(f\"Error with h={h}: {error}\")"
]
},
{
@@ -246,7 +255,7 @@
],
"source": [
"k = np.arange(1, 10 + 1)\n",
"h_list = 1/np.power(2, k)\n",
"h_list = 1 / np.power(2, k)\n",
"\n",
"errors = []\n",
"for h in h_list:\n",
@@ -258,14 +267,14 @@
"log_h = np.log(h_list)\n",
"log_errors = np.log(errors)\n",
"order = np.polyfit(log_h, log_errors, 1)[0]\n",
" \n",
"\n",
"plt.figure(figsize=(10, 5))\n",
"plt.plot(log_h, log_errors, 'o-', label=f'Erreur (ordre {order:.2f})')\n",
"plt.plot(log_h, log_h, '--', label='h')\n",
"plt.plot(log_h, 2*log_h, '--', label='h^2')\n",
"plt.plot(log_h, 4*log_h, '--', label='h^4')\n",
"plt.xlabel('log(h)')\n",
"plt.ylabel('log(error)')\n",
"plt.plot(log_h, log_errors, \"o-\", label=f\"Erreur (ordre {order:.2f})\")\n",
"plt.plot(log_h, log_h, \"--\", label=\"h\")\n",
"plt.plot(log_h, 2 * log_h, \"--\", label=\"h^2\")\n",
"plt.plot(log_h, 4 * log_h, \"--\", label=\"h^4\")\n",
"plt.xlabel(\"log(h)\")\n",
"plt.ylabel(\"log(error)\")\n",
"plt.legend()\n",
"plt.grid(True)\n",
"plt.show()\n",
@@ -306,11 +315,14 @@
"source": [
"def F(t, Y):\n",
" x, y, z = Y\n",
" return np.array([\n",
" 1 + np.power(x, 2) * y - (z + 1) * x,\n",
" x * z - np.power(x, 2) * y,\n",
" - x * z + 1.45\n",
" ])\n",
" return np.array(\n",
" [\n",
" 1 + np.power(x, 2) * y - (z + 1) * x,\n",
" x * z - np.power(x, 2) * y,\n",
" -x * z + 1.45,\n",
" ]\n",
" )\n",
"\n",
"\n",
"h = 0.025\n",
"y0 = np.array([1, 1, 1])\n",
@@ -320,20 +332,20 @@
"y = RKI(F, y0, t)\n",
"fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))\n",
"\n",
"ax1.scatter(y[0], y[1], label='Solution numérique', color='red')\n",
"ax1.plot(sol_exact[:, 0], sol_exact[:, 1], label='Solution exacte', color='blue')\n",
"ax1.scatter(y[0], y[1], label=\"Solution numérique\", color=\"red\")\n",
"ax1.plot(sol_exact[:, 0], sol_exact[:, 1], label=\"Solution exacte\", color=\"blue\")\n",
"ax1.legend()\n",
"ax1.set_title('x vs y')\n",
"ax1.set_title(\"x vs y\")\n",
"\n",
"ax2.scatter(y[1], y[2], label='Solution numérique', color='red')\n",
"ax2.plot(sol_exact[:, 1], sol_exact[:, 2], label='Solution exacte', color='blue')\n",
"ax2.scatter(y[1], y[2], label=\"Solution numérique\", color=\"red\")\n",
"ax2.plot(sol_exact[:, 1], sol_exact[:, 2], label=\"Solution exacte\", color=\"blue\")\n",
"ax2.legend()\n",
"ax2.set_title('y vs z')\n",
"ax2.set_title(\"y vs z\")\n",
"\n",
"ax3.scatter(y[0], y[2], label='Solution numérique', color='red')\n",
"ax3.plot(sol_exact[:, 0], sol_exact[:, 2], label='Solution exacte', color='blue')\n",
"ax3.scatter(y[0], y[2], label=\"Solution numérique\", color=\"red\")\n",
"ax3.plot(sol_exact[:, 0], sol_exact[:, 2], label=\"Solution exacte\", color=\"blue\")\n",
"ax3.legend()\n",
"ax3.set_title('x vs z')\n",
"ax3.set_title(\"x vs z\")\n",
"\n",
"plt.tight_layout()\n",
"plt.show()"
@@ -357,14 +369,15 @@
],
"source": [
"def R(z):\n",
" return (1 + 3/4 * z * (1 + z/6)/(1 - z/6)) / (1 - z/4)\n",
" return (1 + 3 / 4 * z * (1 + z / 6) / (1 - z / 6)) / (1 - z / 4)\n",
"\n",
"\n",
"x = np.linspace(-15, 5, 100)\n",
"y = np.linspace(-7.5, 7.5, 100)\n",
"X, Y = np.meshgrid(x, y)\n",
"Z = R(X + 1j*Y)\n",
"Z = R(X + 1j * Y)\n",
"plt.figure(figsize=(10, 7))\n",
"plt.contour(X, Y, np.abs(Z), levels=[1], cmap='rainbow')\n",
"plt.contour(X, Y, np.abs(Z), levels=[1], cmap=\"rainbow\")\n",
"plt.grid()\n",
"plt.show()"
]

494
M1/Numerical Optimisation/ComputerSession1.ipynb
View File

File diff suppressed because one or more lines are too long

13
M1/Numerical Optimisation/ComputerSession2.ipynb
View File

@@ -308,7 +308,6 @@
}
],
"source": [
"import numpy as np\n",
"\n",
"u = lambda x: np.sqrt((6 - x) ** 2 + 4)\n",
"\n",
@@ -364,7 +363,9 @@
"# Run Newton's method\n",
"optimal_point_newton, iterations_newton = newton_method(initial_guess_newton)\n",
"print(f\"Optimal point (Newton): {optimal_point_newton}\")\n",
"print(f\"Objective function value at optimal point (Newton): {objective_function(optimal_point_newton)}\")\n",
"print(\n",
" f\"Objective function value at optimal point (Newton): {objective_function(optimal_point_newton)}\"\n",
")\n",
"print(f\"Number of iterations (Newton): {iterations_newton}\")\n",
"\n",
"# Initial interval for dichotomy method\n",
@@ -373,7 +374,9 @@
"# Run dichotomy method\n",
"optimal_point_dichotomy, iterations_dichotomy = dichotomy_method(aL, aR)\n",
"print(f\"Optimal point (Dichotomy): {optimal_point_dichotomy}\")\n",
"print(f\"Objective function value at optimal point (Dichotomy): {objective_function(optimal_point_dichotomy)}\")\n",
"print(\n",
" f\"Objective function value at optimal point (Dichotomy): {objective_function(optimal_point_dichotomy)}\"\n",
")\n",
"print(f\"Number of iterations (Dichotomy): {iterations_dichotomy}\")"
]
},
@@ -564,9 +567,7 @@
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n"
]
"source": []
}
],
"metadata": {

62
M1/Numerical Optimisation/ComputerSession3.ipynb
View File

@@ -42,20 +42,24 @@
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def generate_thetas(n):\n",
" random_steps = np.random.random(n)\n",
" return np.concatenate(([0], np.cumsum(random_steps / np.sum(random_steps) * (2*np.pi))))\n",
" return np.concatenate(\n",
" ([0], np.cumsum(random_steps / np.sum(random_steps) * (2 * np.pi)))\n",
" )\n",
"\n",
"\n",
"n = 4\n",
"thetas = generate_thetas(n)\n",
"thetas_inf = np.linspace(0, 2*np.pi, 1000)\n",
"thetas_inf = np.linspace(0, 2 * np.pi, 1000)\n",
"\n",
"plt.figure(figsize=(7, 7))\n",
"plt.plot(np.cos(thetas), np.sin(thetas), label='polygon')\n",
"plt.scatter(np.cos(thetas), np.sin(thetas), color='red', label='vertices')\n",
"plt.plot(np.cos(thetas_inf), np.sin(thetas_inf), 'k--', label='unit circle', alpha=0.5)\n",
"plt.plot(np.cos(thetas), np.sin(thetas), label=\"polygon\")\n",
"plt.scatter(np.cos(thetas), np.sin(thetas), color=\"red\", label=\"vertices\")\n",
"plt.plot(np.cos(thetas_inf), np.sin(thetas_inf), \"k--\", label=\"unit circle\", alpha=0.5)\n",
"plt.legend()\n",
"plt.title(f'Polygon with {n} sides')\n",
"plt.title(f\"Polygon with {n} sides\")\n",
"plt.grid(True)\n",
"plt.xlim(-1.1, 1.1)\n",
"plt.ylim(-1.1, 1.1)\n",
@@ -207,58 +211,61 @@
}
],
"source": [
"from cProfile import label\n",
"import numpy as np\n",
"from scipy.optimize import minimize\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"def polygon_perimeter(theta, n):\n",
" points = np.array([[np.cos(t), np.sin(t)] for t in theta])\n",
" perimeter = 0\n",
" for i in range(n-1):\n",
" perimeter += np.sqrt(np.sum((points[i+1] - points[i])**2))\n",
" perimeter += np.sqrt(np.sum((points[0] - points[-1])**2))\n",
" for i in range(n - 1):\n",
" perimeter += np.sqrt(np.sum((points[i + 1] - points[i]) ** 2))\n",
" perimeter += np.sqrt(np.sum((points[0] - points[-1]) ** 2))\n",
" return -perimeter\n",
"\n",
"\n",
"def constraint_increasing(theta):\n",
" return np.array([theta[i+1] - theta[i] for i in range(len(theta)-1)])\n",
" return np.array([theta[i + 1] - theta[i] for i in range(len(theta) - 1)])\n",
"\n",
"\n",
"def optimize_polygon(n):\n",
" theta0 = generate_thetas(n)\n",
" \n",
"\n",
" constraints = [\n",
" {'type': 'ineq', 'fun': constraint_increasing},\n",
" {'type': 'eq', 'fun': lambda x: x[0]},\n",
" {'type': 'ineq', 'fun': lambda x: 2*np.pi - x[-1]}\n",
" {\"type\": \"ineq\", \"fun\": constraint_increasing},\n",
" {\"type\": \"eq\", \"fun\": lambda x: x[0]},\n",
" {\"type\": \"ineq\", \"fun\": lambda x: 2 * np.pi - x[-1]},\n",
" ]\n",
"\n",
" result = minimize(\n",
" lambda x: polygon_perimeter(x, n),\n",
" theta0,\n",
" constraints=constraints,\n",
" method='SLSQP'\n",
" method=\"SLSQP\",\n",
" )\n",
" \n",
"\n",
" return result.x\n",
"\n",
"\n",
"def plot_perimeter(n):\n",
" optimal_angles = optimize_polygon(n + 1)\n",
" plt.figure(figsize=(7, 7))\n",
" t = np.linspace(0, 2*np.pi, 100)\n",
" plt.plot(np.cos(t), np.sin(t), 'k--', alpha=0.5, label='unit circle')\n",
" t = np.linspace(0, 2 * np.pi, 100)\n",
" plt.plot(np.cos(t), np.sin(t), \"k--\", alpha=0.5, label=\"unit circle\")\n",
"\n",
" points = np.array([[np.cos(t), np.sin(t)] for t in optimal_angles])\n",
" points = np.vstack([points, points[0]])\n",
" plt.plot(points[:, 0], points[:, 1], 'b-', linewidth=2, label='optimal polygon')\n",
" plt.scatter(points[:-1, 0], points[:-1, 1], color='red', label='vertices')\n",
" plt.plot(points[:, 0], points[:, 1], \"b-\", linewidth=2, label=\"optimal polygon\")\n",
" plt.scatter(points[:-1, 0], points[:-1, 1], color=\"red\", label=\"vertices\")\n",
"\n",
" plt.legend()\n",
" plt.axis('equal')\n",
" plt.axis(\"equal\")\n",
" plt.grid(True)\n",
" plt.title(f'Optimal {n}-sided Polygon Inscribed in Unit Circle')\n",
" plt.xlabel('x')\n",
" plt.ylabel('y')\n",
" plt.axis('equal')\n",
" plt.title(f\"Optimal {n}-sided Polygon Inscribed in Unit Circle\")\n",
" plt.xlabel(\"x\")\n",
" plt.ylabel(\"y\")\n",
" plt.axis(\"equal\")\n",
" plt.grid(True)\n",
" plt.show()\n",
"\n",
@@ -266,6 +273,7 @@
" print(f\"Maximum perimeter: {-polygon_perimeter(optimal_angles, n)}\")\n",
" print(f\"2 * pi = {2 * np.pi}\")\n",
"\n",
"\n",
"for n in np.arange(3, 10, 1):\n",
" plot_perimeter(n)"
]
@@ -316,9 +324,11 @@
"source": [
"x0 = np.array([2, -1, 3, 0, -5])\n",
"\n",
"\n",
"def K(x):\n",
" return np.minimum(x, 0)\n",
"\n",
"\n",
"print(f\"Initial point: {x0}\")\n",
"print(f\"Projection of x0 onto K: {K(x0)}\")"
]

241
M1/Portfolio Management/TP-Project.ipynb
View File

@@ -1,8 +1,9 @@
{
"cells": [
{
"metadata": {},
"cell_type": "markdown",
"id": "81049114d821d00e",
"metadata": {},
"source": [
"# Project - Portfolio Management\n",
"\n",
@@ -11,52 +12,36 @@
"### Time period studied from 2017-01-01 to 2018-01-01\n",
"\n",
"### Risk-free rate: 2%"
],
"id": "81049114d821d00e"
]
},
{
"cell_type": "code",
"execution_count": 51,
"id": "initial_id",
"metadata": {
"collapsed": true,
"ExecuteTime": {
"end_time": "2024-11-25T13:43:46.298758Z",
"start_time": "2024-11-25T13:43:46.293696Z"
}
},
"collapsed": true
},
"outputs": [],
"source": [
"import yfinance as yf\n",
"import pandas as pd\n",
"import numpy as np"
],
"outputs": [],
"execution_count": 51
]
},
{
"cell_type": "code",
"execution_count": 52,
"id": "9f9fc36832c97e0",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:47.318911Z",
"start_time": "2024-11-25T13:43:47.198820Z"
}
},
"cell_type": "code",
"source": [
"# Data Extraction\n",
"Tickers = [\"^RUT\", \"^IXIC\", \"^GSPC\", \"XWD.TO\"]\n",
"start_input = \"2017-01-01\"\n",
"end_input = \"2018-01-01\"\n",
"S = pd.DataFrame()\n",
"for t in Tickers:\n",
" S[t] = yf.Tickers(t).history(start=start_input, end=end_input)[\"Close\"]\n",
"\n",
"S = S.interpolate(method=\"pad\")\n",
"\n",
"# Show the first five and last five values extracted\n",
"display(S.head())\n",
"display(S.tail())\n",
"print(S.shape)"
],
"id": "9f9fc36832c97e0",
"outputs": [
{
"name": "stderr",
@@ -72,15 +57,6 @@
},
{
"data": {
"text/plain": [
" ^RUT ^IXIC ^GSPC XWD.TO\n",
"Date \n",
"2017-01-03 00:00:00+00:00 1365.489990 5429.080078 2257.830078 38.499630\n",
"2017-01-04 00:00:00+00:00 1387.949951 5477.000000 2270.750000 38.553375\n",
"2017-01-05 00:00:00+00:00 1371.939941 5487.939941 2269.000000 38.481716\n",
"2017-01-06 00:00:00+00:00 1367.280029 5521.060059 2276.979980 38.517544\n",
"2017-01-09 00:00:00+00:00 1357.489990 5531.819824 2268.899902 38.383186"
],
"text/html": [
"<div>\n",
"<style scoped>\n",
@@ -152,6 +128,15 @@
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ^RUT ^IXIC ^GSPC XWD.TO\n",
"Date \n",
"2017-01-03 00:00:00+00:00 1365.489990 5429.080078 2257.830078 38.499630\n",
"2017-01-04 00:00:00+00:00 1387.949951 5477.000000 2270.750000 38.553375\n",
"2017-01-05 00:00:00+00:00 1371.939941 5487.939941 2269.000000 38.481716\n",
"2017-01-06 00:00:00+00:00 1367.280029 5521.060059 2276.979980 38.517544\n",
"2017-01-09 00:00:00+00:00 1357.489990 5531.819824 2268.899902 38.383186"
]
},
"metadata": {},
@@ -159,15 +144,6 @@
},
{
"data": {
"text/plain": [
" ^RUT ^IXIC ^GSPC XWD.TO\n",
"Date \n",
"2017-12-22 00:00:00+00:00 1542.930054 6959.959961 2683.340088 44.323349\n",
"2017-12-26 00:00:00+00:00 1544.229980 6936.250000 2680.500000 44.323349\n",
"2017-12-27 00:00:00+00:00 1543.939941 6939.339844 2682.620117 44.052303\n",
"2017-12-28 00:00:00+00:00 1548.930054 6950.160156 2687.540039 43.857414\n",
"2017-12-29 00:00:00+00:00 1535.510010 6903.390137 2673.610107 43.784576"
],
"text/html": [
"<div>\n",
"<style scoped>\n",
@@ -239,6 +215,15 @@
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ^RUT ^IXIC ^GSPC XWD.TO\n",
"Date \n",
"2017-12-22 00:00:00+00:00 1542.930054 6959.959961 2683.340088 44.323349\n",
"2017-12-26 00:00:00+00:00 1544.229980 6936.250000 2680.500000 44.323349\n",
"2017-12-27 00:00:00+00:00 1543.939941 6939.339844 2682.620117 44.052303\n",
"2017-12-28 00:00:00+00:00 1548.930054 6950.160156 2687.540039 43.857414\n",
"2017-12-29 00:00:00+00:00 1535.510010 6903.390137 2673.610107 43.784576"
]
},
"metadata": {},
@@ -252,63 +237,69 @@
]
}
],
"execution_count": 52
"source": [
"# Data Extraction\n",
"Tickers = [\"^RUT\", \"^IXIC\", \"^GSPC\", \"XWD.TO\"]\n",
"start_input = \"2017-01-01\"\n",
"end_input = \"2018-01-01\"\n",
"S = pd.DataFrame()\n",
"for t in Tickers:\n",
" S[t] = yf.Tickers(t).history(start=start_input, end=end_input)[\"Close\"]\n",
"\n",
"S = S.interpolate(method=\"pad\")\n",
"\n",
"# Show the first five and last five values extracted\n",
"display(S.head())\n",
"display(S.tail())\n",
"print(S.shape)"
]
},
{
"cell_type": "code",
"execution_count": 53,
"id": "53483cf3a925a4db",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:50.080380Z",
"start_time": "2024-11-25T13:43:50.073119Z"
}
},
"cell_type": "code",
"outputs": [],
"source": [
"R = S / S.shift() - 1\n",
"R = R[1:]\n",
"mean_d = R.mean()\n",
"covar_d = R.cov()\n",
"corr = R.corr()"
],
"id": "53483cf3a925a4db",
"outputs": [],
"execution_count": 53
]
},
{
"cell_type": "code",
"execution_count": 54,
"id": "c327ed5967b1f442",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:50.965092Z",
"start_time": "2024-11-25T13:43:50.961969Z"
}
},
"cell_type": "code",
"outputs": [],
"source": [
"mean = mean_d * 252\n",
"covar = covar_d * 252\n",
"std = np.sqrt(np.diag(covar))"
],
"id": "c327ed5967b1f442",
"outputs": [],
"execution_count": 54
]
},
{
"cell_type": "code",
"execution_count": 55,
"id": "6bc6a850bf06cc9d",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:51.701725Z",
"start_time": "2024-11-25T13:43:51.695020Z"
}
},
"cell_type": "code",
"source": [
"print(\"Mean:\\n\")\n",
"print(mean)\n",
"print(\"\\nCovariance:\\n\")\n",
"print(covar)\n",
"print(\"\\nStandard Deviation:\\n\")\n",
"print(std)\n",
"print(\"\\nCorrelation:\\n\")\n",
"print(corr)"
],
"id": "6bc6a850bf06cc9d",
"outputs": [
{
"name": "stdout",
@@ -344,22 +335,34 @@
]
}
],
"execution_count": 55
"source": [
"print(\"Mean:\\n\")\n",
"print(mean)\n",
"print(\"\\nCovariance:\\n\")\n",
"print(covar)\n",
"print(\"\\nStandard Deviation:\\n\")\n",
"print(std)\n",
"print(\"\\nCorrelation:\\n\")\n",
"print(corr)"
]
},
{
"metadata": {},
"cell_type": "markdown",
"source": "# Question 1",
"id": "fc4bec874f710f7c"
"id": "fc4bec874f710f7c",
"metadata": {},
"source": "# Question 1"
},
{
"cell_type": "code",
"execution_count": 56,
"id": "780c9cca6e0ed2d3",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:53.113423Z",
"start_time": "2024-11-25T13:43:53.109514Z"
}
},
"cell_type": "code",
"outputs": [],
"source": [
"r = 0.02\n",
"d = len(Tickers)\n",
@@ -369,32 +372,18 @@
"\n",
"a = vec1.T.dot(inv_sigma).dot(vec1)\n",
"b = mean.T.dot(inv_sigma).dot(vec1)"
],
"id": "780c9cca6e0ed2d3",
"outputs": [],
"execution_count": 56
]
},
{
"cell_type": "code",
"execution_count": 57,
"id": "81c956f147c68070",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:54.545400Z",
"start_time": "2024-11-25T13:43:54.541579Z"
}
},
"cell_type": "code",
"source": [
"# Tangent portfolio\n",
"pi_T = inv_sigma.dot(mean - r * vec1) / (b - r * a)\n",
"sd_T = np.sqrt(pi_T.T.dot(sigma).dot(pi_T)) # Variance\n",
"m_T = pi_T.T.dot(mean) # expected return\n",
"\n",
"print(f\"Expected return m_T: {m_T}\")\n",
"print(f\"Standard deviation sd_T: {sd_T}\")\n",
"print(f\"Allocation pi_T: {pi_T}\")\n",
"print(\n",
" f\"We can verify that the allocation is possible as the sum of the allocations for the different indices is {sum(pi_T)}, that is very close to 1\")"
],
"id": "81c956f147c68070",
"outputs": [
{
"name": "stdout",
@@ -407,32 +396,36 @@
]
}
],
"execution_count": 57
"source": [
"# Tangent portfolio\n",
"pi_T = inv_sigma.dot(mean - r * vec1) / (b - r * a)\n",
"sd_T = np.sqrt(pi_T.T.dot(sigma).dot(pi_T)) # Variance\n",
"m_T = pi_T.T.dot(mean) # expected return\n",
"\n",
"print(f\"Expected return m_T: {m_T}\")\n",
"print(f\"Standard deviation sd_T: {sd_T}\")\n",
"print(f\"Allocation pi_T: {pi_T}\")\n",
"print(\n",
" f\"We can verify that the allocation is possible as the sum of the allocations for the different indices is {sum(pi_T)}, that is very close to 1\"\n",
")"
]
},
{
"metadata": {},
"cell_type": "markdown",
"source": "# Question 2",
"id": "2e121c2dfb946f3c"
"id": "2e121c2dfb946f3c",
"metadata": {},
"source": "# Question 2"
},
{
"cell_type": "code",
"execution_count": 58,
"id": "c169808384ca1112",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:43:59.797115Z",
"start_time": "2024-11-25T13:43:59.792462Z"
}
},
"cell_type": "code",
"source": [
"for i in range(len(std)):\n",
" print(f\"The annualized volatilities of the index {Tickers[i]} is {std[i]}\")\n",
" print(f\"The annualized expected returns of the index {Tickers[i]} is {mean[Tickers[i]]}\")\n",
" print(\"\")\n",
"\n",
"print(f\"The annualized volatility of the Tangent Portfolio is {sd_T * np.sqrt(252)}\")\n",
"print(f\"The annualized expected return of the Tangent Portfolio is {m_T * 252}\")"
],
"id": "c169808384ca1112",
"outputs": [
{
"name": "stdout",
@@ -455,29 +448,34 @@
]
}
],
"execution_count": 58
"source": [
"for i in range(len(std)):\n",
" print(f\"The annualized volatilities of the index {Tickers[i]} is {std[i]}\")\n",
" print(\n",
" f\"The annualized expected returns of the index {Tickers[i]} is {mean[Tickers[i]]}\"\n",
" )\n",
" print(\"\")\n",
"\n",
"print(f\"The annualized volatility of the Tangent Portfolio is {sd_T * np.sqrt(252)}\")\n",
"print(f\"The annualized expected return of the Tangent Portfolio is {m_T * 252}\")"
]
},
{
"metadata": {},
"cell_type": "markdown",
"source": "# Question 3",
"id": "af8d29ecdbf2ae1"
"id": "af8d29ecdbf2ae1",
"metadata": {},
"source": "# Question 3"
},
{
"cell_type": "code",
"execution_count": 59,
"id": "2e0215ab7904906a",
"metadata": {
"ExecuteTime": {
"end_time": "2024-11-25T13:44:01.393591Z",
"start_time": "2024-11-25T13:44:01.388830Z"
}
},
"cell_type": "code",
"source": [
"print(\"sharpe ratio of the Tangent portfolio :\", (m_T - r) / sd_T)\n",
"\n",
"for i in range(4):\n",
" print(f\"the sharpe ratio of the index {Tickers[i]} is {(mean[Tickers[i]] - r) / std[i]}\")"
],
"id": "2e0215ab7904906a",
"outputs": [
{
"name": "stdout",
@@ -491,7 +489,14 @@
]
}
],
"execution_count": 59
"source": [
"print(\"sharpe ratio of the Tangent portfolio :\", (m_T - r) / sd_T)\n",
"\n",
"for i in range(4):\n",
" print(\n",
" f\"the sharpe ratio of the index {Tickers[i]} is {(mean[Tickers[i]] - r) / std[i]}\"\n",
" )"
]
}
],
"metadata": {

402
M1/Portfolio Management/TP1.ipynb
View File

File diff suppressed because one or more lines are too long

516
M1/Statistical Learning/TP0_Intro_Jupyter_Python.ipynb
View File

File diff suppressed because one or more lines are too long

376
M1/Statistical Learning/TP1_A_first_example.ipynb
View File

File diff suppressed because one or more lines are too long

658
M1/Statistical Learning/TP2_KNN.ipynb
View File

File diff suppressed because one or more lines are too long

357
M1/Statistical Learning/TP2_bis_OPTIONAL.ipynb
View File

File diff suppressed because one or more lines are too long

582
M1/Statistical Learning/TP3_Logistic_Regression_and _SGD.ipynb
View File

File diff suppressed because one or more lines are too long

91
M1/Statistical Learning/TP4_Ridge_Lasso_and_CV.ipynb
View File

@@ -43,7 +43,7 @@
"source": [
"import warnings\n",
"\n",
"warnings.filterwarnings('ignore')"
"warnings.filterwarnings(\"ignore\")"
]
},
{
@@ -434,7 +434,7 @@
],
"source": [
"import numpy as np\n",
"import pandas as pd # dataframes are in pandas \n",
"import pandas as pd # dataframes are in pandas\n",
"import matplotlib.pyplot as plt\n",
"\n",
"hitters = pd.read_csv(\"data/Hitters.csv\", index_col=\"Name\")\n",
@@ -895,9 +895,13 @@
],
"source": [
"# Hint for Question (4) :\n",
"ex = pd.DataFrame(dict(nom=['Alice', 'Nicolas', 'Jean'],\n",
" age=[19, np.NaN, np.NaN],\n",
" exam=[15, 14, np.NaN]))\n",
"ex = pd.DataFrame(\n",
" dict(\n",
" nom=[\"Alice\", \"Nicolas\", \"Jean\"],\n",
" age=[19, np.NaN, np.NaN],\n",
" exam=[15, 14, np.NaN],\n",
" )\n",
")\n",
"\n",
"print(\"data : \\n\", ex)\n",
"print(\"First result : \\n\", ex.isnull())\n",
@@ -1080,10 +1084,10 @@
],
"source": [
"# We remove the players for whom Salary is missing\n",
"hitters.dropna(subset=['Salary'], inplace=True)\n",
"hitters.dropna(subset=[\"Salary\"], inplace=True)\n",
"\n",
"X = hitters.select_dtypes(include=int)\n",
"Y = hitters['Salary']\n",
"Y = hitters[\"Salary\"]\n",
"\n",
"# check-point\n",
"print(Y.isnull().sum()) # should be 0\n",
@@ -1109,7 +1113,7 @@
},
"outputs": [],
"source": [
"#Answer for Exercise 4\n",
"# Answer for Exercise 4\n",
"from sklearn.model_selection import train_test_split\n",
"\n",
"Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=0.3, random_state=42)"
@@ -1697,8 +1701,8 @@
}
],
"source": [
"#the values of alphas chosen by defaults are also on a logarithmic scale\n",
"plt.plot(np.log10(alphas_lasso), '.')"
"# the values of alphas chosen by defaults are also on a logarithmic scale\n",
"plt.plot(np.log10(alphas_lasso), \".\")"
]
},
{
@@ -1735,8 +1739,8 @@
"source": [
"fig, ax = plt.subplots(figsize=(8, 6))\n",
"ax.plot(np.log10(alphas_lasso), coefs_lasso)\n",
"ax.set_xlabel('log10(alpha)')\n",
"ax.set_ylabel('Lasso coefficients')"
"ax.set_xlabel(\"log10(alpha)\")\n",
"ax.set_ylabel(\"Lasso coefficients\")"
]
},
{
@@ -1792,7 +1796,7 @@
"print(\"1.\\n\", ind)\n",
"print(\"2.\\n\", ind == 0)\n",
"print(\"3. Le nombre de 0 de chaque colonne est :\\n \", (ind == 0).sum(axis=0))\n",
"print(\"4. Le nombre de 0 de chaque ligne est : \\n\", (ind == 0).sum(axis=1))\n"
"print(\"4. Le nombre de 0 de chaque ligne est : \\n\", (ind == 0).sum(axis=1))"
]
},
{
@@ -2294,18 +2298,19 @@
"from sklearn.linear_model import LinearRegression\n",
"\n",
"linReg = LinearRegression()\n",
"linReg.fit(Xtrain,\n",
" Ytrain) # no need to scale for OLS if you just want to predict (unless the solver works best with scaled data)\n",
"linReg.fit(\n",
" Xtrain, Ytrain\n",
") # no need to scale for OLS if you just want to predict (unless the solver works best with scaled data)\n",
"# the predictions should not be different with or without standardization (could differ only owing to numerical problems)\n",
"hatY_LinReg = linReg.predict(Xtest)\n",
"\n",
"fig, ax = plt.subplots()\n",
"ax.scatter(Ytest, hatY_LinReg, s=5)\n",
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls='--', c='gray')\n",
"ax.set_xlabel('Ytest')\n",
"ax.set_ylabel('hatY')\n",
"ax.set_title('Predicted vs true salaries for OLS estimator')\n",
"ax.axis('square')"
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls=\"--\", c=\"gray\")\n",
"ax.set_xlabel(\"Ytest\")\n",
"ax.set_ylabel(\"hatY\")\n",
"ax.set_title(\"Predicted vs true salaries for OLS estimator\")\n",
"ax.axis(\"square\")"
]
},
{
@@ -2355,11 +2360,11 @@
"\n",
"fig, ax = plt.subplots()\n",
"ax.scatter(Ytest, hatY_ridge, s=5)\n",
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls='--', c='gray')\n",
"ax.set_xlabel('Ytest')\n",
"ax.set_ylabel('hatY')\n",
"ax.set_title('Predicted vs true salaries for Ridge estimator')\n",
"ax.axis('square')"
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls=\"--\", c=\"gray\")\n",
"ax.set_xlabel(\"Ytest\")\n",
"ax.set_ylabel(\"hatY\")\n",
"ax.set_title(\"Predicted vs true salaries for Ridge estimator\")\n",
"ax.axis(\"square\")"
]
},
{
@@ -2408,11 +2413,11 @@
"\n",
"fig, ax = plt.subplots()\n",
"ax.scatter(Ytest, hatY_lasso, s=5)\n",
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls='--', c='gray')\n",
"ax.set_xlabel('Ytest')\n",
"ax.set_ylabel('hatY')\n",
"ax.set_title('Predicted vs true salaries for Ridge estimator')\n",
"ax.axis('square')"
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls=\"--\", c=\"gray\")\n",
"ax.set_xlabel(\"Ytest\")\n",
"ax.set_ylabel(\"hatY\")\n",
"ax.set_title(\"Predicted vs true salaries for Ridge estimator\")\n",
"ax.axis(\"square\")"
]
},
{
@@ -2445,7 +2450,7 @@
"source": [
"from sklearn.linear_model import LassoLarsIC\n",
"\n",
"lassoBIC = LassoLarsIC(criterion='bic')\n",
"lassoBIC = LassoLarsIC(criterion=\"bic\")\n",
"lassoBIC.fit(XtrainScaled, Ytrain)\n",
"print(\"best alpha chosen by BIC criterion :\", lassoBIC.alpha_)\n",
"print(\"best alpha chosen by CV :\", lassoCV.alpha_)\n",
@@ -2499,11 +2504,11 @@
"\n",
"fig, ax = plt.subplots()\n",
"ax.scatter(Ytest, hatY_BIC, s=5)\n",
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls='--', c='gray')\n",
"ax.set_xlabel('Ytest')\n",
"ax.set_ylabel('hatY')\n",
"ax.set_title('Predicted vs true salaries for LassoBIC estimator')\n",
"ax.axis('square')"
"ax.plot([0, 1], [0, 1], transform=ax.transAxes, ls=\"--\", c=\"gray\")\n",
"ax.set_xlabel(\"Ytest\")\n",
"ax.set_ylabel(\"hatY\")\n",
"ax.set_title(\"Predicted vs true salaries for LassoBIC estimator\")\n",
"ax.axis(\"square\")"
]
},
{
@@ -2539,7 +2544,9 @@
"from sklearn.metrics import mean_squared_error\n",
"\n",
"MSEs = []\n",
"for name, estimator in zip([\"LassoCV\", \"LassoBIC\", \"RidgeCV\", \"OLS\"], [lassoCV, lassoBIC, ridgeCV, linReg]):\n",
"for name, estimator in zip(\n",
" [\"LassoCV\", \"LassoBIC\", \"RidgeCV\", \"OLS\"], [lassoCV, lassoBIC, ridgeCV, linReg]\n",
"):\n",
" y_pred = estimator.predict(Xtest)\n",
" MSE = mean_squared_error(Ytest, y_pred)\n",
" print(f\"MSE for {name} : {MSE}\")\n",
@@ -2584,10 +2591,12 @@
"ols_errors = np.abs(Ytest - linReg.predict(Xtest))\n",
"\n",
"fig, ax = plt.subplots(figsize=(10, 6))\n",
"ax.boxplot([ridge_cv_errors, lasso_cv_errors, lasso_bic_errors, ols_errors],\n",
" labels=['RidgeCV', 'LassoCV', 'LassoBIC', 'OLS'])\n",
"ax.set_title('Boxplot of Absolute Errors')\n",
"ax.set_ylabel('Absolute Error')\n",
"ax.boxplot(\n",
" [ridge_cv_errors, lasso_cv_errors, lasso_bic_errors, ols_errors],\n",
" labels=[\"RidgeCV\", \"LassoCV\", \"LassoBIC\", \"OLS\"],\n",
")\n",
"ax.set_title(\"Boxplot of Absolute Errors\")\n",
"ax.set_ylabel(\"Absolute Error\")\n",
"plt.show()"
]
},

128
M1/Statistical Learning/TP5_Naive_Bayes.ipynb
View File

@@ -32,7 +32,7 @@
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd \n",
"import pandas as pd\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt"
]
@@ -226,7 +226,7 @@
}
],
"source": [
"sms = pd.read_csv(\"data/spam.csv\", encoding='latin')\n",
"sms = pd.read_csv(\"data/spam.csv\", encoding=\"latin\")\n",
"\n",
"sms.head()"
]
@@ -244,7 +244,7 @@
"metadata": {},
"outputs": [],
"source": [
"sms.rename(columns={'v1':'Label', 'v2':'Text'}, inplace=True)"
"sms.rename(columns={\"v1\": \"Label\", \"v2\": \"Text\"}, inplace=True)"
]
},
{
@@ -644,7 +644,7 @@
}
],
"source": [
"sms['Labelnum']=sms['Label'].map({'ham':0,'spam':1})\n",
"sms[\"Labelnum\"] = sms[\"Label\"].map({\"ham\": 0, \"spam\": 1})\n",
"\n",
"sms.head()"
]
@@ -674,13 +674,13 @@
}
],
"source": [
"# Hint 1 for Exercise 1 \n",
"a=np.array([0,1,1,1,0])\n",
"print (len(a))\n",
"print (a[a==0])\n",
"print (len(a[a==0]))\n",
"print (a[a==1])\n",
"print (len(a[a==1]))"
"# Hint 1 for Exercise 1\n",
"a = np.array([0, 1, 1, 1, 0])\n",
"print(len(a))\n",
"print(a[a == 0])\n",
"print(len(a[a == 0]))\n",
"print(a[a == 1])\n",
"print(len(a[a == 1]))"
]
},
{
@@ -881,8 +881,8 @@
}
],
"source": [
"# Hint 2 for Exercise 1 \n",
"sms[sms.Labelnum==0].head()"
"# Hint 2 for Exercise 1\n",
"sms[sms.Labelnum == 0].head()"
]
},
{
@@ -1083,8 +1083,8 @@
}
],
"source": [
"# Hint 3 for Exercise 1 \n",
"sms[sms.Labelnum==1].head()"
"# Hint 3 for Exercise 1\n",
"sms[sms.Labelnum == 1].head()"
]
},
{
@@ -1104,8 +1104,8 @@
],
"source": [
"print(len(sms))\n",
"print(sms[sms.Label == 'ham'].shape)\n",
"print(sms[sms.Label == 'spam'].shape)"
"print(sms[sms.Label == \"ham\"].shape)\n",
"print(sms[sms.Label == \"spam\"].shape)"
]
},
{
@@ -1136,8 +1136,8 @@
],
"source": [
"# Hint 1 for Exercise 2\n",
"print (sms.loc[0, 'Text']) \n",
"print (\"--> The length of the first sms is\", len(sms.loc[0, 'Text']))"
"print(sms.loc[0, \"Text\"])\n",
"print(\"--> The length of the first sms is\", len(sms.loc[0, \"Text\"]))"
]
},
{
@@ -1160,10 +1160,13 @@
],
"source": [
"plt.figure(figsize=(10, 6))\n",
"plt.hist(sms.loc[:, 'Text'].apply(len), bins='stone',)\n",
"plt.title('Histogram of SMS Lengths')\n",
"plt.xlabel('Length')\t\n",
"plt.ylabel('Frequency')\n",
"plt.hist(\n",
" sms.loc[:, \"Text\"].apply(len),\n",
" bins=\"stone\",\n",
")\n",
"plt.title(\"Histogram of SMS Lengths\")\n",
"plt.xlabel(\"Length\")\n",
"plt.ylabel(\"Frequency\")\n",
"plt.show()"
]
},
@@ -1222,30 +1225,41 @@
}
],
"source": [
"Example = pd.DataFrame([['iphone gratuit iphone gratuit',1],['mille vert gratuit',0],\n",
" ['iphone mille euro',0],['argent gratuit euro gratuit',1]],\n",
" columns=['sms', 'label'])\n",
"Example = pd.DataFrame(\n",
" [\n",
" [\"iphone gratuit iphone gratuit\", 1],\n",
" [\"mille vert gratuit\", 0],\n",
" [\"iphone mille euro\", 0],\n",
" [\"argent gratuit euro gratuit\", 1],\n",
" ],\n",
" columns=[\"sms\", \"label\"],\n",
")\n",
"vec = CountVectorizer()\n",
"X = vec.fit_transform(Example.sms)\n",
"\n",
"# 1. Displaying the vocabulary\n",
"\n",
"print (\"1. The vocabulary of Example is \", vec.vocabulary_)\n",
"print(\"1. The vocabulary of Example is \", vec.vocabulary_)\n",
"\n",
"# 1 bis :\n",
"\n",
"print('The vocabulary arranged in alphabetical order : ', sorted(list(vec.vocabulary_.keys())))\n",
"print(\n",
" \"The vocabulary arranged in alphabetical order : \",\n",
" sorted(list(vec.vocabulary_.keys())),\n",
")\n",
"\n",
"# 2. Displaying the vectors : \n",
"# 2. Displaying the vectors :\n",
"\n",
"print (\"2. The vectors corresponding to the sms are : \\n\", X.toarray())# X.toarray because \n",
"# X is a \"sparse\" matrix. \n",
"print(\n",
" \"2. The vectors corresponding to the sms are : \\n\", X.toarray()\n",
") # X.toarray because\n",
"# X is a \"sparse\" matrix.\n",
"\n",
"# 3. For a new data x_0=\"iphone gratuit\", \n",
"# you must also transform x_0 into a numerical vector before predicting. \n",
"# 3. For a new data x_0=\"iphone gratuit\",\n",
"# you must also transform x_0 into a numerical vector before predicting.\n",
"\n",
"vec_x_0=vec.transform(['iphone gratuit']).toarray() # \n",
"print (\"3. The numerical vector corresponding to (x_0=iphone gratuit) is \\n\", vec_x_0 )"
"vec_x_0 = vec.transform([\"iphone gratuit\"]).toarray() #\n",
"print(\"3. The numerical vector corresponding to (x_0=iphone gratuit) is \\n\", vec_x_0)"
]
},
{
@@ -1267,7 +1281,7 @@
],
"source": [
"#'sparse' version (without \"to_array\")\n",
"v = vec.transform(['iphone iphone gratuit'])\n",
"v = vec.transform([\"iphone iphone gratuit\"])\n",
"v"
]
},
@@ -1309,8 +1323,8 @@
}
],
"source": [
"# \"(0,2) 1\" means : the element in row 0 and column 2 is equal to 1. \n",
"# \"(0,3) 2\" means : the element in row 0 and column 3 is equal to 2. \n",
"# \"(0,2) 1\" means : the element in row 0 and column 2 is equal to 1.\n",
"# \"(0,3) 2\" means : the element in row 0 and column 3 is equal to 2.\n",
"print(v)"
]
},
@@ -1340,8 +1354,8 @@
}
],
"source": [
"vec_x_1 = vec.transform(['iphone vert gratuit']).toarray()\n",
"vec_x_2 = vec.transform(['iphone rouge gratuit']).toarray()\n",
"vec_x_1 = vec.transform([\"iphone vert gratuit\"]).toarray()\n",
"vec_x_2 = vec.transform([\"iphone rouge gratuit\"]).toarray()\n",
"print(vec_x_1)\n",
"print(vec_x_2)"
]
@@ -1372,8 +1386,8 @@
"outputs": [],
"source": [
"vectorizer = CountVectorizer()\n",
"X = vectorizer.fit_transform(sms['Text'])\n",
"y = sms['Labelnum']"
"X = vectorizer.fit_transform(sms[\"Text\"])\n",
"y = sms[\"Labelnum\"]"
]
},
{
@@ -1400,10 +1414,12 @@
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.30,random_state=50)\n",
"X_train, X_test, y_train, y_test = train_test_split(\n",
" X, y, test_size=0.30, random_state=50\n",
")\n",
"\n",
"print (\"size of the training set: \", X_train.shape[0])\n",
"print (\"size of the test set :\", X_test.shape[0])"
"print(\"size of the training set: \", X_train.shape[0])\n",
"print(\"size of the test set :\", X_test.shape[0])"
]
},
{
@@ -1906,7 +1922,7 @@
"from sklearn.metrics import accuracy_score\n",
"\n",
"y_pred = sms_bayes.predict(X_test)\n",
"print (\"The accuracy score on the test set is \", accuracy_score(y_test, y_pred))"
"print(\"The accuracy score on the test set is \", accuracy_score(y_test, y_pred))"
]
},
{
@@ -1969,10 +1985,17 @@
}
],
"source": [
"my_sms = vectorizer.transform(['free trial!', 'Iphone 15 is now free', 'I want coffee', 'I want to buy a new iphone'])\n",
"my_sms = vectorizer.transform(\n",
" [\n",
" \"free trial!\",\n",
" \"Iphone 15 is now free\",\n",
" \"I want coffee\",\n",
" \"I want to buy a new iphone\",\n",
" ]\n",
")\n",
"\n",
"pred_my_sms = sms_bayes.predict(my_sms)\n",
"print (pred_my_sms)"
"print(pred_my_sms)"
]
},
{
@@ -1999,7 +2022,7 @@
"from sklearn.naive_bayes import BernoulliNB\n",
"\n",
"# Load the MNIST dataset\n",
"mnist = fetch_openml('mnist_784', version=1, parser='auto')\n",
"mnist = fetch_openml(\"mnist_784\", version=1, parser=\"auto\")\n",
"X, y = mnist.data, mnist.target"
]
},
@@ -2036,7 +2059,9 @@
"source": [
"X_copy = (X.copy() >= 127).astype(int)\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X_copy, y, test_size=0.25, random_state=42)\n",
"X_train, X_test, y_train, y_test = train_test_split(\n",
" X_copy, y, test_size=0.25, random_state=42\n",
")\n",
"\n",
"ber_bayes = BernoulliNB()\n",
"ber_bayes.fit(X_train, y_train)\n",
@@ -2059,6 +2084,7 @@
"outputs": [],
"source": [
"from keras.datasets import cifar10\n",
"\n",
"(x_train, y_train), (x_test, y_test) = cifar10.load_data()"
]
},
@@ -2077,7 +2103,7 @@
}
],
"source": [
"# reminder : the output is an RGB image 32 x 32 \n",
"# reminder : the output is an RGB image 32 x 32\n",
"print(x_train.shape)\n",
"print(y_train.shape)"
]

4467
M1/Statistical Learning/TP6_keras_intro.ipynb
View File

File diff suppressed because one or more lines are too long

107
M1/Statistical Learning/TP7_Kmeans.ipynb
View File

@@ -46,23 +46,23 @@
"\n",
"\n",
"np.random.seed(12)\n",
"num_observations=400\n",
"num_observations = 400\n",
"\n",
"center1=[0,0]\n",
"center2=[1,4]\n",
"center3=[-3,2]\n",
"center1 = [0, 0]\n",
"center2 = [1, 4]\n",
"center3 = [-3, 2]\n",
"\n",
"x1=np.random.multivariate_normal(center1,[[1,0],[0,1]], num_observations)\n",
"x2=np.random.multivariate_normal(center2,[[1,0],[0,1]], num_observations)\n",
"x3=np.random.multivariate_normal(center3,[[1,0],[0,1]], num_observations)\n",
"x1 = np.random.multivariate_normal(center1, [[1, 0], [0, 1]], num_observations)\n",
"x2 = np.random.multivariate_normal(center2, [[1, 0], [0, 1]], num_observations)\n",
"x3 = np.random.multivariate_normal(center3, [[1, 0], [0, 1]], num_observations)\n",
"\n",
"X= np.vstack((x1, x2, x3)).astype(np.float32)\n",
"X = np.vstack((x1, x2, x3)).astype(np.float32)\n",
"\n",
"plt.figure(figsize=(8,6))\n",
"plt.plot(X[:,0], X[:,1],\".b\",alpha=0.2)\n",
"plt.plot(center1[0], center1[1], '.', color='red', markersize=10)\n",
"plt.plot(center2[0], center2[1], '.', color='red', markersize=10)\n",
"plt.plot(center3[0], center3[1], '.', color='red', markersize=10)\n",
"plt.figure(figsize=(8, 6))\n",
"plt.plot(X[:, 0], X[:, 1], \".b\", alpha=0.2)\n",
"plt.plot(center1[0], center1[1], \".\", color=\"red\", markersize=10)\n",
"plt.plot(center2[0], center2[1], \".\", color=\"red\", markersize=10)\n",
"plt.plot(center3[0], center3[1], \".\", color=\"red\", markersize=10)\n",
"plt.show()"
]
},
@@ -540,10 +540,12 @@
}
],
"source": [
"plt.figure(figsize=(8,6))\n",
"plt.plot(X[:,0], X[:,1],\".b\",alpha=0.2)\n",
"plt.figure(figsize=(8, 6))\n",
"plt.plot(X[:, 0], X[:, 1], \".b\", alpha=0.2)\n",
"for center in kmeans1.cluster_centers_:\n",
" plt.plot(center[0], center[1], '.', color='red', markersize=10, label='Cluster center')\n",
" plt.plot(\n",
" center[0], center[1], \".\", color=\"red\", markersize=10, label=\"Cluster center\"\n",
" )\n",
"plt.legend()\n",
"plt.show()"
]
@@ -585,11 +587,11 @@
"# Hint: An example for plotting the Voronoi partition\n",
"from scipy.spatial import Voronoi, voronoi_plot_2d\n",
"\n",
"points_generer_voronoi = np.array([[0,0],[1,4],[-3,2]])\n",
"points_generer_voronoi = np.array([[0, 0], [1, 4], [-3, 2]])\n",
"\n",
"vor = Voronoi(points_generer_voronoi)\n",
"\n",
"fig, ax = plt.subplots(1,1,figsize=(4,4)) \n",
"fig, ax = plt.subplots(1, 1, figsize=(4, 4))\n",
"\n",
"fig = voronoi_plot_2d(vor, ax=ax, show_vertices=False)"
]
@@ -614,14 +616,16 @@
"# Answer for Exercise 3\n",
"\n",
"\n",
"fig, ax = plt.subplots(1,1,figsize=(8,6)) \n",
"plt.plot(X[:,0], X[:,1], \".b\", alpha=0.2)\n",
"fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
"plt.plot(X[:, 0], X[:, 1], \".b\", alpha=0.2)\n",
"\n",
"vor = Voronoi(kmeans1.cluster_centers_)\n",
"fig = voronoi_plot_2d(vor, ax=ax, show_vertices=False)\n",
"\n",
"for center in kmeans1.cluster_centers_:\n",
" plt.plot(center[0], center[1], '.', color='red', markersize=10, label='Cluster center')\n",
" plt.plot(\n",
" center[0], center[1], \".\", color=\"red\", markersize=10, label=\"Cluster center\"\n",
" )\n",
"plt.legend()\n",
"plt.show()"
]
@@ -1233,10 +1237,10 @@
}
],
"source": [
"print (\"1:\", compress_model.labels_)\n",
"print (\"2:\", compress_model.labels_.shape)\n",
"print (\"3:\", compress_model.cluster_centers_)\n",
"print (\"4:\", compress_model.cluster_centers_.shape)"
"print(\"1:\", compress_model.labels_)\n",
"print(\"2:\", compress_model.labels_.shape)\n",
"print(\"3:\", compress_model.cluster_centers_)\n",
"print(\"4:\", compress_model.cluster_centers_.shape)"
]
},
{
@@ -1275,13 +1279,13 @@
"metadata": {},
"outputs": [],
"source": [
"color_new=np.zeros_like(colors)\n",
"color_new = np.zeros_like(colors)\n",
"\n",
"labels=compress_model.labels_\n",
"centers=compress_model.cluster_centers_\n",
"labels = compress_model.labels_\n",
"centers = compress_model.cluster_centers_\n",
"\n",
"for i in range(len(colors)):\n",
" color_new[i]= centers[labels[i]]"
" color_new[i] = centers[labels[i]]"
]
},
{
@@ -1336,11 +1340,12 @@
],
"source": [
"import matplotlib.image as mpimg\n",
"\n",
"mpimg.imsave(\"assets/zelda_new.png\", zelda_new)\n",
"\n",
"plt.figure(figsize=(8, 6))\n",
"plt.imshow(zelda_new)\n",
"plt.show()\n"
"plt.show()"
]
},
{
@@ -1363,13 +1368,13 @@
"source": [
"import os\n",
"\n",
"size_new=os.path.getsize('assets/zelda_new.png')\n",
"size_old=os.path.getsize('assets/zelda.png')\n",
"size_new = os.path.getsize(\"assets/zelda_new.png\")\n",
"size_old = os.path.getsize(\"assets/zelda.png\")\n",
"\n",
"print (\"The original size is \", size_old, \"bytes.\")\n",
"print (\"The compressed size is \", size_new, \"bytes.\")\n",
"print(\"The original size is \", size_old, \"bytes.\")\n",
"print(\"The compressed size is \", size_new, \"bytes.\")\n",
"\n",
"print (f\"The compression factor is {size_old/size_new : .3f}\")"
"print(f\"The compression factor is {size_old / size_new: .3f}\")"
]
},
{
@@ -1407,8 +1412,8 @@
}
],
"source": [
"partiel=plt.imread(\"assets/partiel.png\")\n",
"plt.figure(figsize = (20,10))\n",
"partiel = plt.imread(\"assets/partiel.png\")\n",
"plt.figure(figsize=(20, 10))\n",
"plt.imshow(partiel)"
]
},
@@ -1426,7 +1431,7 @@
}
],
"source": [
"print (partiel.shape)"
"print(partiel.shape)"
]
},
{
@@ -1472,23 +1477,23 @@
}
],
"source": [
"partiel_new=np.zeros_like(partiel)\n",
"partiel_new = np.zeros_like(partiel)\n",
"\n",
"noir_rgb=np.array([0,0,0])\n",
"blanc_rgb=np.array([1,1,1])\n",
"noir_rgb = np.array([0, 0, 0])\n",
"blanc_rgb = np.array([1, 1, 1])\n",
"\n",
"epsilon = 0.5 # threshold\n",
"\n",
"epsilon=0.5 # threshold\n",
" \n",
"distances = np.linalg.norm(partiel - noir_rgb, axis=2)\n",
"partiel_new = np.zeros_like(partiel)\n",
"partiel_new[distances <= epsilon] = noir_rgb\n",
"partiel_new[distances > epsilon] = blanc_rgb\n",
" \n",
"\n",
"mpimg.imsave(\"assets/partiel_new.png\", partiel_new)\n",
"\n",
"plt.figure(figsize=(20,10))\n",
"plt.figure(figsize=(20, 10))\n",
"plt.imshow(partiel_new)\n",
"plt.show()\n"
"plt.show()"
]
},
{
@@ -1531,16 +1536,20 @@
"mnist = tf.keras.datasets.mnist\n",
"(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
"\n",
"X_train = X_train.reshape(-1, 28*28)\n",
"X_train = X_train.reshape(-1, 28 * 28)\n",
"\n",
"kmeans2 = KMeans(n_clusters=10)\n",
"clusters = kmeans2.fit_predict(X_train)\n",
"\n",
"\n",
"def map_clusters_to_labels(clusters, true_labels):\n",
" return np.array([mode(true_labels[clusters == i], keepdims=True).mode[0] for i in range(10)])\n",
" return np.array(\n",
" [mode(true_labels[clusters == i], keepdims=True).mode[0] for i in range(10)]\n",
" )\n",
"\n",
"\n",
"cluster_to_label = map_clusters_to_labels(clusters, y_train)\n",
"print(\"Cluster to label mapping:\", cluster_to_label)\n"
"print(\"Cluster to label mapping:\", cluster_to_label)"
]
},
{

83
M1/Statistical Learning/neural_network.ipynb
View File

@@ -6,7 +6,7 @@
"metadata": {},
"outputs": [],
"source": [
"import numpy as np \n",
"import numpy as np\n",
"import pandas as pd\n",
"import tensorflow as tf\n",
"import matplotlib.pyplot as plt"
@@ -178,16 +178,21 @@
"outputs": [],
"source": [
"def build_model():\n",
" model = tf.keras.models.Sequential([\n",
" tf.keras.layers.Dense(16, activation='relu', input_shape=(X.shape[1],), kernel_regularizer=tf.keras.regularizers.l2(0.01)),\n",
" tf.keras.layers.Dense(8, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.01)),\n",
" tf.keras.layers.Dense(1, activation='sigmoid')\n",
" ])\n",
" model.compile(\n",
" optimizer='adam',\n",
" loss='binary_crossentropy',\n",
" metrics=['accuracy']\n",
" model = tf.keras.models.Sequential(\n",
" [\n",
" tf.keras.layers.Dense(\n",
" 16,\n",
" activation=\"relu\",\n",
" input_shape=(X.shape[1],),\n",
" kernel_regularizer=tf.keras.regularizers.l2(0.01),\n",
" ),\n",
" tf.keras.layers.Dense(\n",
" 8, activation=\"relu\", kernel_regularizer=tf.keras.regularizers.l2(0.01)\n",
" ),\n",
" tf.keras.layers.Dense(1, activation=\"sigmoid\"),\n",
" ]\n",
" )\n",
" model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])\n",
" return model"
]
},
@@ -291,10 +296,7 @@
"histories = []\n",
"\n",
"early_stopping = EarlyStopping(\n",
" monitor='val_loss',\n",
" patience=10,\n",
" restore_best_weights=True,\n",
" verbose=1\n",
" monitor=\"val_loss\", patience=10, restore_best_weights=True, verbose=1\n",
")\n",
"\n",
"for fold, (train_idx, val_idx) in enumerate(skf.split(X, y), 1):\n",
@@ -305,29 +307,28 @@
" scaler = StandardScaler()\n",
" X_train_scaled = scaler.fit_transform(X_train)\n",
" X_val_scaled = scaler.transform(X_val)\n",
" \n",
"\n",
" model = build_model()\n",
"\n",
" model.compile(\n",
" optimizer='adam',\n",
" loss='binary_crossentropy',\n",
" metrics=[\"f1_score\"]\n",
" )\n",
" model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"f1_score\"])\n",
"\n",
" # EarlyStopping\n",
" callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\n",
" callback = tf.keras.callbacks.EarlyStopping(\n",
" monitor=\"val_loss\", patience=10, restore_best_weights=True\n",
" )\n",
"\n",
" # Entraînement\n",
" history = model.fit(\n",
" X_train_scaled, y_train,\n",
" X_train_scaled,\n",
" y_train,\n",
" epochs=50,\n",
" batch_size=8,\n",
" validation_data=(X_val_scaled, y_val),\n",
" callbacks=[callback],\n",
" verbose=0,\n",
" class_weight={0: 1.0, 1: 2.0}\n",
" class_weight={0: 1.0, 1: 2.0},\n",
" )\n",
" \n",
"\n",
" histories.append(history.history)\n",
"\n",
" # Prédiction & F1\n",
@@ -360,9 +361,9 @@
"axes = axes.flatten() # Flatten to easily iterate\n",
"\n",
"for i, (hist, ax) in enumerate(zip(histories, axes)):\n",
" ax.plot(hist['loss'], label='Train loss', alpha=0.6)\n",
" ax.plot(hist['val_loss'], label='Val loss', linestyle='--', alpha=0.6)\n",
" ax.set_title(f\"Fold {i+1}\")\n",
" ax.plot(hist[\"loss\"], label=\"Train loss\", alpha=0.6)\n",
" ax.plot(hist[\"val_loss\"], label=\"Val loss\", linestyle=\"--\", alpha=0.6)\n",
" ax.set_title(f\"Fold {i + 1}\")\n",
" ax.set_xlabel(\"Epochs\")\n",
" if i % 2 == 0:\n",
" ax.set_ylabel(\"Binary Crossentropy\")\n",
@@ -436,7 +437,9 @@
"import tensorflow as tf\n",
"import numpy as np\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
"X_train, X_test, y_train, y_test = train_test_split(\n",
" X, y, test_size=0.2, random_state=42, stratify=y\n",
")\n",
"\n",
"scaler = StandardScaler()\n",
"X_train_scaled = scaler.fit_transform(X_train)\n",
@@ -444,21 +447,21 @@
"\n",
"model = build_model()\n",
"\n",
"model.compile(\n",
" optimizer='adam',\n",
" loss='binary_crossentropy'\n",
"model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\")\n",
"\n",
"callback = tf.keras.callbacks.EarlyStopping(\n",
" monitor=\"val_loss\", patience=10, restore_best_weights=True\n",
")\n",
"\n",
"callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\n",
"\n",
"history = model.fit(\n",
" X_train_scaled, y_train,\n",
" X_train_scaled,\n",
" y_train,\n",
" epochs=50,\n",
" batch_size=8,\n",
" validation_split=0.2,\n",
" callbacks=[callback],\n",
" verbose=0,\n",
" class_weight={0: 1.0, 1: 2.0}\n",
" class_weight={0: 1.0, 1: 2.0},\n",
")\n",
"\n",
"\n",
@@ -486,11 +489,11 @@
],
"source": [
"plt.figure(figsize=(8, 5))\n",
"plt.plot(history.history['loss'], label='Loss (train)')\n",
"plt.plot(history.history['val_loss'], label='Loss (val)', linestyle='--')\n",
"plt.xlabel('Epochs')\n",
"plt.ylabel('Binary Cross-Entropy Loss')\n",
"plt.title('Courbe d\\'apprentissage')\n",
"plt.plot(history.history[\"loss\"], label=\"Loss (train)\")\n",
"plt.plot(history.history[\"val_loss\"], label=\"Loss (val)\", linestyle=\"--\")\n",
"plt.xlabel(\"Epochs\")\n",
"plt.ylabel(\"Binary Cross-Entropy Loss\")\n",
"plt.title(\"Courbe d'apprentissage\")\n",
"plt.legend()\n",
"plt.grid(True)\n",
"plt.tight_layout()\n",

53
pyproject.toml
View File

@@ -11,7 +11,6 @@ dependencies = [
"opencv-python>=4.11.0.86",
"pandas>=2.2.3",
"scikit-learn>=1.6.1",
"tensorflow==2.19.0",
]
[dependency-groups]
@@ -19,3 +18,55 @@ dev = [
"ipykernel>=6.29.5",
"uv>=0.6.16",
]
[tool.ruff.lint]
# Activer les règles de linting courantes
select = [
"E", # pycodestyle errors
"W", # pycodestyle warnings
"F", # Pyflakes
"I", # isort
"B", # flake8-bugbear
"C4", # flake8-comprehensions
"UP", # pyupgrade
]
# Désactiver certaines règles
ignore = [
"E501", # line too long, géré par le formatter
]
# Longueur de ligne
line-length = 88
# Exclure certains fichiers ou répertoires
exclude = [
".bzr",
".direnv",
".eggs",
".git",
".hg",
".mypy_cache",
".nox",
".pants.d",
".pytype",
".ruff_cache",
".svn",
".tox",
".venv",
"__pypackages__",
"_build",
"buck-out",
"build",
"dist",
"node_modules",
"venv",
]
# Permettre à Ruff de corriger automatiquement certaines erreurs
fixable = ["ALL"]
unfixable = []
# Formatage des imports
[isort]
known-third-party = ["pydantic", "django"]