init: initial commit

1 files changed, 529 insertions, 0 deletions

diff --git a/PVCM/cama/fr/ma1 np90 petits exercices.ipynb b/PVCM/cama/fr/ma1 np90 petits exercices.ipynb
new file mode 100644
index 0000000..8b08f12
--- /dev/null
+++ b/PVCM/cama/fr/ma1 np90 petits exercices.ipynb
@@ -0,0 +1,529 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "048aaf2b",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "# Numpy - Exercices\n",
+    "\n",
+    "Voici une série de tests pour vérifier ses connaissances en Numpy. Le but est que cette bibliothèque et la programmation vectorielle qu'elle implique deviennent naturelles. Il faut oublier la programmation classique avec des boucles (il ne faut pas utiliser de boucle `for` ou autre dans cette feuille en dehors de construction de [liste en compréhension](../../lesson1%20Python%20basics/03%20-%20Tests%20et%20boucles.ipynb) ).\n",
+    "\n",
+    "Les fonctions ne doivent jamais modifier les arguements.\n",
+    "\n",
+    "Les exercices indique le nombre de ligne de la réponse. Cela comprend l'en-tête de la fonction lorsqu'il y en a une.\n",
+    "\n",
+    "Pensez à tester vos résultats."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8c0a79d0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[ 0  1  2  3]\n",
+      " [ 4  5  6  7]\n",
+      " [ 8  9 10 11]] \n",
+      "\n",
+      "[[  3  -8  -8  -4   7]\n",
+      " [  9   0  -9 -10   7]\n",
+      " [  5  -1 -10   4 -10]\n",
+      " [  5   9   4  -6 -10]\n",
+      " [  6  -6   7  -7  -8]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "rand = np.random.RandomState(123)\n",
+    "\n",
+    "A = np.arange(12).reshape(3,4)\n",
+    "B = rand.randint(-10, 10, size=(5,5))\n",
+    "print(A, '\\n')\n",
+    "print(B)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "51317493",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Matrice carrée\n",
+    "\n",
+    "Créer la matrice carrée 5x5 qui contient les 25 premiers entiers, de 1 à 25.\n",
+    "\n",
+    "1 ligne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "14ccdaf5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 1,  2,  3,  4,  5],\n",
+       "       [ 6,  7,  8,  9, 10],\n",
+       "       [11, 12, 13, 14, 15],\n",
+       "       [16, 17, 18, 19, 20],\n",
+       "       [21, 22, 23, 24, 25]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.arange(1, 26).reshape(5,5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b797402",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Norme d'un vecteur\n",
+    "\n",
+    "Retourner la norme euclidienne d'un vecteur sans utiliser la fonction `norm`.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "079b9d00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def norm(v):\n",
+    "    return np.sqrt(v.dot(v))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05888df0",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Sous-matrice\n",
+    "\n",
+    "Extraire la sous-matrice de taille (n-2)x(m-2) qui retire les bords de la matrice A de taille nxm.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c313908",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 6,  7,  8],\n",
+       "       [11, 12, 13],\n",
+       "       [16, 17, 18]])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def submat(A):\n",
+    "    return A[1:-1,1:-1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8569c30",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Vecteur aléatoire\n",
+    "\n",
+    "Créer une fonction qui prend une taille n et retourne un vecteur  d'entiers aléatoire de taille n compris entre -a et +a et centré le plus possible en 0.\n",
+    "\n",
+    "3 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e93d8900",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rand_vec(n, a):\n",
+    "    return np.random.normal(scale=a/2,size=n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fedb8b70",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Trace\n",
+    "\n",
+    "Retourner la trace d'une matrice sans utiliser la fonction `trace` (à vous de chercher les éléments qui vous manque).\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "8df7f55b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def trace(A):\n",
+    "    return np.sum(np.diag(A))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e1c14f2",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Matrice de multiples de 3\n",
+    "\n",
+    "Arrondir la matrice donnée au multiple de 3 le plus proche (pour chaque valeur).\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "55860b91",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def round3(A):\n",
+    "    return np.vectorize(lambda n : 3 * round(n / 3))(A)\n",
+    "    #return [3 * round(number / 3) for number in row for row in A]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68b9db16",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Nombre de 9\n",
+    "\n",
+    "Compter le nombre de 9 dans une matrice d'entier A donnée en paramètre.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9296a705",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def nb9(A):\n",
+    "    return len(A[A == 9])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2927718",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Colonne qui a la plus petite moyenne\n",
+    "\n",
+    "Retourner l'indice de la colonne d'une matrice ayant la plus petite moyenne.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3c9d6a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.int64(0)"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def min_col_mean(A):\n",
+    "    return np.argmin(A.mean(axis=0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e2591d1",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### ChessSum\n",
+    "\n",
+    "On regarde la matrice comme un échequier avec des cases blanches et des cases noires qui alternent. La case en [0,0] est noire. \n",
+    "Calculer la somme des valeurs sur les cases blanches.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "3921063c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chess_sum(A):\n",
+    "    return np.sum(A[0::2,1::2]) + np.sum(A[1::2,0::2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e0ffb99",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### 2 minimums\n",
+    "\n",
+    "Retourner les 2 plus petites valeurs d'une matrice avec une méthode de complexité linéaire. Attention, si la matrice a sa valeur minimal en double, la réponse est deux fois cette valeur minimale.\n",
+    "\n",
+    "6 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b680cc53",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[np.int64(1), np.int64(2)]"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def mins(A):\n",
+    "    t = np.min(A)\n",
+    "    if len(A[A == t]) == 1:\n",
+    "        return [t,np.min(A[A > t])]\n",
+    "    return [t,t]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0265738a",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Lignes dans l'ordre\n",
+    "\n",
+    "Ranger les lignes d'une matrice dans l'ordre croissant de leur moyenne.\n",
+    "\n",
+    "2 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "5784c5be",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 2, 3],\n",
+       "       [4, 5, 6],\n",
+       "       [7, 8, 9]])"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def sort_lines(A):\n",
+    "    return A[A.sum(axis=1).argsort()]\n",
+    "sort_lines(np.array([[4, 5, 6],\n",
+    "        [1, 2, 3],       \n",
+    "       [7, 8, 9]]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c80e353",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Valeurs uniques\n",
+    "\n",
+    "Donner la liste des valeurs uniques (qui n'apparaissent qu'une fois) dans un tableau numpy (la fonction `unique` sera utile).\n",
+    "\n",
+    "3 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "id": "c95ce1bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([], dtype=int64)"
+      ]
+     },
+     "execution_count": 97,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def val_unique(A):\n",
+    "    res = np.unique(A, equal_nan=False, return_index=True, return_counts=True)\n",
+    "    return A.flatten()[res[1][res[2] == 1]]\n",
+    "val_unique(np.array([[1,1,1],[3,3,3]]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "006b473a",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Tenseur magique\n",
+    "\n",
+    "Constuire un tenseur 3D de taille nxnxn en utilisant n fois les n² premiers entiers et de sorte que la sommme des éléments de chaque plan (coupe) est toujours la même.\n",
+    "\n",
+    "3 lignes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1ca40c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mk_magic_tensor(n):\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "405f3308",
+   "metadata": {
+    "lang": "fr"
+   },
+   "source": [
+    "### Plans d'un tenseur\n",
+    "\n",
+    "Extraire tous les plans d'un tenseur 3d. On retourne une liste de tableaux.\n",
+    "\n",
+    "5 lignes (2 lignes avec la fonction `take`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e4d39b2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_planes(T):\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "761e6ee4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}