3 premier chap de 'alea'

.gitignore

@@ -3,4 +3,4 @@
 **/__pycache__
 **/.ipynb_checkpoints/
 **/.DS_Store
-
+**/build
\ No newline at end of file

.idea/inspectionProfiles/Project_Default.xml

@@ -5,8 +5,10 @@
     <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ourVersions">
         <value>
-          <list size="1">
+          <list size="3">
             <item index="0" class="java.lang.String" itemvalue="3.5" />
+            <item index="1" class="java.lang.String" itemvalue="3.6" />
+            <item index="2" class="java.lang.String" itemvalue="3.7" />
           </list>
         </value>
       </option>

.idea/misc.xml

@@ -4,4 +4,7 @@
     <option name="languageLevel" value="ES6" />
   </component>
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6" project-jdk-type="Python SDK" />
+  <component name="PythonCompatibilityInspectionAdvertiser">
+    <option name="version" value="3" />
+  </component>
 </project>
\ No newline at end of file

alea/08-Chaine_de_Markov.ipynb

@@ -19,302 +19,6 @@
     "np.set_printoptions(precision=3,suppress=True)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Préliminaires d'algèbre linéaire\n",
-    "\n",
-    "Attention, en numpy les vecteurs, les matrices lignes et les matrices colonnes sont des objets différents:\n",
-    "\n",
-    "* vecteur.shape = (?)\n",
-    "* matrice_ligne.shape = (1,?)\n",
-    "* matrice_colonne.shape = (?,1)\n",
-    "* matrice_quelconque.shape = (?,?)\n",
-    "\n",
-    "Observez bien les sorties consoles: les vecteurs s'écrivent avec 1 crochet, les matrices avec 2 crochets.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Multiplication matricielle\n",
-    "\n",
-    "`np.matmul()` s'applique uniquement entre matrices."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "mat_col\n",
-      " [[1.]\n",
-      " [1.]\n",
-      " [1.]]\n",
-      "\n",
-      "mat_lin\n",
-      " [[1. 1. 1.]]\n",
-      "\n",
-      "mat_square\n",
-      " [[1. 1. 1.]\n",
-      " [1. 1. 1.]\n",
-      " [1. 1. 1.]]\n",
-      "\n",
-      "mat_square × mat_col\n",
-      " [[3.]\n",
-      " [3.]\n",
-      " [3.]]\n",
-      "\n",
-      "mat_lin × mat_square\n",
-      " [[3. 3. 3.]]\n",
-      "\n",
-      "mat_lin × mat_square × mat_col\n",
-      " [[9.]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "size=3\n",
-    "mat_col=np.ones(shape=[size,1])\n",
-    "mat_lin=np.ones(shape=[1,size])\n",
-    "mat_square=np.ones(shape=[size,size])\n",
-    "\n",
-    "print(\"\\nmat_col\\n\",mat_col)\n",
-    "print(\"\\nmat_lin\\n\",mat_lin)\n",
-    "print(\"\\nmat_square\\n\",mat_square)\n",
-    "\n",
-    "print(\"\\nmat_square × mat_col\\n\",np.matmul(mat_square,mat_col) )\n",
-    "print(\"\\nmat_lin × mat_square\\n\",np.matmul(mat_lin,mat_square))\n",
-    "print(\"\\nmat_lin × mat_square × mat_col\\n\", np.matmul(np.matmul(mat_lin,mat_square),mat_col))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "sinon on peut utiliser `np.dot()` qui permet les multiplications matrice × vecteur, matrice × matrice, vecteur ×  vecteur (=produit scalaire)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "vec0 × vec1\n",
-      " 6.0\n",
-      "\n",
-      "vec0 × mat_square\n",
-      " [3. 3. 3.]\n",
-      "\n",
-      "mat_square × vec0\n",
-      " [3. 3. 3.]\n",
-      "\n",
-      "mat_square × mat_square\n",
-      " [[3. 3. 3.]\n",
-      " [3. 3. 3.]\n",
-      " [3. 3. 3.]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "size=3\n",
-    "vec0=np.ones(shape=[size])\n",
-    "vec1=2*np.ones(shape=[size])\n",
-    "mat_square=np.ones(shape=[size,size])\n",
-    "\n",
-    "print(\"\\nvec0 × vec1\\n\",np.dot(vec0,vec1))\n",
-    "print(\"\\nvec0 × mat_square\\n\",np.dot(vec0,mat_square))\n",
-    "print(\"\\nmat_square × vec0\\n\",np.dot(mat_square,vec0))\n",
-    "print(\"\\nmat_square × mat_square\\n\",np.dot(mat_square,mat_square))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "et si vous avez python 3.5+, vous pouver utilisez l'opérateur @ qui rend les codes plus lisibles"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "vec0 × vec1\n",
-      " 6.0\n",
-      "\n",
-      "vec0 × mat_square\n",
-      " [3. 3. 3.]\n",
-      "\n",
-      "mat_square × vec0\n",
-      " [3. 3. 3.]\n",
-      "\n",
-      "mat_square × mat_square\n",
-      " [[3. 3. 3.]\n",
-      " [3. 3. 3.]\n",
-      " [3. 3. 3.]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"\\nvec0 × vec1\\n\",vec0 @ vec1)\n",
-    "print(\"\\nvec0 × mat_square\\n\",vec0 @ mat_square)\n",
-    "print(\"\\nmat_square × vec0\\n\",mat_square @ vec0)\n",
-    "print(\"\\nmat_square × mat_square\\n\",mat_square @  mat_square)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "***Exo:*** Multipliez matriciellement des matrices de taille non-compatible.\n",
-    "Extrayez la partie intéressante du message d'erreur."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### inverse et transposée \n",
-    "\n",
-    "Notez que le pseudo-inverse permet d'inverser les matrices non-inversibles (testez). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "mat\n",
-      " [[1. 0. 2.]\n",
-      " [0. 1. 0.]\n",
-      " [0. 0. 1.]]\n",
-      "\n",
-      "mat^T\n",
-      " [[1. 0. 0.]\n",
-      " [0. 1. 0.]\n",
-      " [2. 0. 1.]]\n",
-      "\n",
-      "mat^(-1)\n",
-      " [[ 1.  0. -2.]\n",
-      " [ 0.  1.  0.]\n",
-      " [ 0.  0.  1.]]\n",
-      "\n",
-      "mat^(-1)-pseudo-inverse\n",
-      " [[ 1.  0. -2.]\n",
-      " [ 0.  1.  0.]\n",
-      " [ 0.  0.  1.]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "size=3\n",
-    "mat=np.zeros(shape=[size,size])\n",
-    "for i in range(size):\n",
-    "    mat[i,i]=1\n",
-    "mat[0,size-1]=2\n",
-    "\n",
-    "\n",
-    "print(\"\\nmat\\n\",mat )\n",
-    "print(\"\\nmat^T\\n\",mat.T)\n",
-    "print(\"\\nmat^(-1)\\n\",np.linalg.inv(mat))\n",
-    "print(\"\\nmat^(-1)-pseudo-inverse\\n\",np.linalg.pinv(mat))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### vecteur propre et valeur propre\n",
-    "\n",
-    "Souvenez-vous qu'en anglais valeur/vecteur 'propre' c'est 'eigen' value/vector"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "mat\n",
-      " [[0.085 0.287 0.206 0.422]\n",
-      " [0.191 0.262 0.253 0.295]\n",
-      " [0.244 0.07  0.06  0.626]\n",
-      " [0.383 0.001 0.161 0.454]]\n",
-      "\n",
-      "eigVal\n",
-      " [ 1.     0.122 -0.195 -0.066]\n",
-      "\n",
-      "eigVec\n",
-      " [[-0.5   -0.416 -0.418  0.39 ]\n",
-      " [-0.5   -0.763  0.307  0.432]\n",
-      " [-0.5    0.402 -0.739 -0.813]\n",
-      " [-0.5    0.287  0.43  -0.036]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "size=4\n",
-    "\"\"\"une matrice aléatoire auquel on fait subir une opération de normalisation (laquelle?)\"\"\"\n",
-    "mat=np.random.uniform(low=0,high=10,size=[size,size])\n",
-    "rowSum=np.sum(mat,axis=1)\n",
-    "\"\"\" mat[i,j]=mat[i,j]/rowSum(i)  \"\"\"\n",
-    "for i in range(size): mat[i,:]/=rowSum[i]\n",
-    "\n",
-    "eigVal,eigVec=np.linalg.eig(mat)\n",
-    "print(\"\\nmat\\n\", mat )\n",
-    "print(\"\\neigVal\\n\",np.real(eigVal))\n",
-    "print(\"\\neigVec\\n\", np.real(eigVec))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "***A vous:*** \n",
-    "\n",
-    "* Pourquoi 1 est-il valeur propre ? Quel est le vecteur propre associé? `np.linalg.eig` donne-t-il les vecteurs propres à droite ou à gauche? Sont-ils disposés en ligne ou bien en colonne?\n",
-    "\n",
-    "* Toutes les matrices sont-elles diagonalisables?  A quoi servent les np.real()?  \n",
-    "\n",
-    "* laquelle de ces deux formules est la bonne ?\n",
-    "\n",
-    "        Diag = P^-1 @ mat @ P   \n",
-    "\n",
-    "ou\n",
-    "\n",
-    "        Diag = P @ mat @ P^-1\n",
-    "        \n",
-    "Vérifiez avec python. Aide: Pour transformez un vecteur en matrice diagonale, utilisez `np.diag(vecteur)`"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},