Add feuille de route 2024 (#70)

* Add feuille de route 2024

* fix issues

* black

_doc/articles/2022/2022-01-01-assurance.rst

@@ -1,6 +1,6 @@
 
-Assurance auto
-==============
+2022 - Assurance auto
+=====================
 
 J'avoue que je ne savais pas trop où allait partir cette
 séance de cours quand je l'ai commencée avec seulement

_doc/articles/2023/2023-11-31-route2023.rst

@@ -1,4 +1,4 @@
-_l-feuille-route-2023:
+.. _l-feuille-route-2023:
 
 2023-11-31 : rappel feuille de route 2023
 =========================================

_doc/articles/2024/2024-09-04-ensae.rst

@@ -0,0 +1,69 @@
+2024-09-04 : ENSAE
+==================
+
+**Notions à maîtriser**
+
+* éléments de bases du langages (boucles, listes, tests, fonctions)
+* classes (attributes, méthodes, opérateurs, héritages)
+* graphes, arbre
+* numpy (opérations standard, broadcasting)
+* format de données (JSON, XML, HTML, csv)
+* tests unitaires (package unittest, git, pull request)
+* algorithmes
+   * tri fusion
+   * recherche dichotomique
+   * graphes (composantes connexes, Kruskal, ...)
+   * programmation dynamique (chemin plus court dans un graphe, distance d'édition)
+   * problème NP-complet tels que le voyageur de commerce
+
+**Notions non abordées**
+
+Elles le seront en seconde année et non en première année : manipulation de données, pandas, machine learning.
+
+**Evaluation**
+
+1 TD noté. Les classes seront abordées et un problème algorithmique.
+Voir aussi les précédents énoncés : :ref:`l-exams`.
+
+**Ressources**
+
+* Ce site : `sdpython.github.io/doc/teachpyx/dev/ <https://sdpython.github.io/doc/teachpyx/dev/>`_
+* :ref:`l-book-python`
+* exercices sur le langage :ref:`l-python`
+* exercices sur des algortihmes :ref:`l-algo`
+* examens passés :ref:`l-exams`
+* :ref:`Plan suivi en 2023 <l-feuille-route-2023>`
+* `Des aspects plus mathématiques d'algorithmes <https://sdpython.github.io/doc/mlstatpy/dev/>`_
+
+**Problème**
+
+Comment écrire un algorithme capable de créer une grille de sudoku ?
+
+.. image:: sudoku.png
+
+**Getting Started**
+
+* `cheat sheet python <https://perso.limsi.fr/pointal/_media/python:cours:mementopython3-english.pdf>`_
+* `Anaconda <https://www.anaconda.com/>`_,
+  `miniconda <https://docs.conda.io/projects/miniconda/en/latest/>`_,
+  `mamba <https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html>`_
+* `Visual Studio Code <https://code.visualstudio.com/>`_
+* `git <https://git-scm.com/>`_, `github <https://github.com/>`_
+* `notebook <https://jupyter.org/>`_
+
+**Sujets connexes**
+
+* Open source et économie du logiciel...
+* Ingéniérie logicielle ou comment produire un logiciel fiable en collaboration...
+* Notion de `test unitaire <https://fr.wikipedia.org/wiki/Test_unitaire>`_,
+  `intégration continue <https://fr.wikipedia.org/wiki/Int%C3%A9gration_continue>`_.
+
+**Demain**
+
+* Intelligence artificielle et puissance de calcul, NVidia
+* Objets connectés...
+* Quantique...
+
+**Hier**
+
+:ref:`l-feuille-route-2023`

_doc/articles/2024/2024-11-31-route2024.rst

@@ -0,0 +1,32 @@
+2024-11-31 : rappel feuille de route 2024
+=========================================
+
+Séance 1
+++++++++
+
+Séance 2
+++++++++
+
+Séance 3
+++++++++
+
+Séance 4
+++++++++
+
+Séance 5
+++++++++
+
+Séance 6
+++++++++
+
+Séance 7
+++++++++
+
+Séance 8
+++++++++
+
+
+TD noté 1h30 en seconde partie.
+Classes et un algorithme.
+Enoncés des années précédentes :
+:ref:`l-exams`.

_doc/articles/index.rst

@@ -9,6 +9,8 @@ Ou *blog*.
     :caption: 2024
     :maxdepth: 1
 
+    2024/2024-11-31-route2024
+    2024/2024-09-04-ensae
     2024/2024-03-01-route2024
     2024/2024-01-18-wsl
 

_doc/conf.py

@@ -102,7 +102,6 @@
     "scipy": ("https://docs.scipy.org/doc/scipy/reference", None),
     "skl2onnx": ("https://onnx.ai/sklearn-onnx/", None),
     "sklearn": ("https://scikit-learn.org/stable/", None),
-    "sklearn-onnx": ("https://onnx.ai/sklearn-onnx/", None),
     "torch": ("https://pytorch.org/docs/stable/", None),
 }
 

_doc/examples/prog/plot_einstein_riddle.py

@@ -11,12 +11,12 @@
 Implémentatin d'une solution à base de règles.
 
 Je la reproduis ici :
- 
-Il y a cinq maisons de cinq couleurs différentes. Dans chacune de ces maisons, 
-vit une personne de nationalité différente. 
+
+Il y a cinq maisons de cinq couleurs différentes. Dans chacune de ces maisons,
+vit une personne de nationalité différente.
 Chacune de ces personnes boit une boisson différente,
 fume un cigare différent et a un animal domestique différent.
- 
+
 1. L'Anglais vit dans la maison rouge.
 2. Le Suédois a des chiens.
 3. Le Danois boit du thé.
@@ -32,58 +32,57 @@
 13. L'Allemand fume des prince.
 14. Le Norvégien vit juste à côté de la maison bleue.
 15. L'homme qui fume des Blend a un voisin qui boit de l'eau.
- 
+
 **Question : Qui a le poisson ?**
- 
+
 Après quelques essais, une bonne feuille de papier, on arrive à
-reconstituer la solution après de nombreuses déductions logiques 
+reconstituer la solution après de nombreuses déductions logiques
 et quelques essais. On peut voir aussi ce jeu comme un puzzle :
 chaque configuration est un pièce du puzzle dont la forme des bords
 est définie par toutes ces règles. Il faut trouver le seul emboîtement
-possible sachant que parfois, une pièce peut s'emboîter avec plusieurs 
+possible sachant que parfois, une pièce peut s'emboîter avec plusieurs
 mais qu'il n'existe qu'une façon de les emboîter toutes ensemble.
 Ecrire un programme qui résoud ce problème revient à s'intéresser à deux problèmes :
- 
+
 1. Comment définir une pièce du puzzle ?
 2. Comment parcourir toutes les combinaisons possibles ?
- 
+
 Chaque règle ou pièce de puzzle peut être exprimer comme une
 `clause <https://fr.wikipedia.org/wiki/Clause_de_Horn)>`_.
-Pour notre problème, chaque pièce du puzzle est simplement décrite par 
+Pour notre problème, chaque pièce du puzzle est simplement décrite par
 un attribut (rouge, norvégien) et un numéro de maisons (1 à 5).
 Les règles définissent la compatibilité de deux pièces. On peut
 regrouper ces règles en cinq catégories :
- 
+
 1. Un attribut est à la position p (règle 9).
 2. Deux attributs sont équivalents (règle 1).
 3. Deux attributs sont voisins (règle 11).
 4. Deux attributs sont ordonnés par rapport aux positions (règle 4).
 5. Deux attributs font partie du même ensemble et sont exclusives :
    on ne peut pas être l'un et l'autre à la fois (rouge et jaune par exemple).
- 
-Une fois que chaque règle a été exprimée dans une de ces cinq catégories, 
+
+Une fois que chaque règle a été exprimée dans une de ces cinq catégories,
 il faut définir l'association de deux règles (ou clause) pour
 former une clause plus complexe. Trois cas possibles :
- 
+
 1. Deux clauses sont compatibles : on peut avoir l'une et l'autre.
 2. Deux clauses sont incompatibles : on ne peut avoir l'une et l'autre.
- 
-Dans le premier cas, la clause résultante est simplement qu'on peut la clause A 
-et la clause B : :math:*A* et *B*. Dans le second cas, il existe deux
+
+Dans le premier cas, la clause résultante est simplement qu'on peut la clause A
+et la clause B : *A* et *B*. Dans le second cas, il existe deux
 possibilités, on peut avoir l'une et l'opposé de l'autre ou l'inverse :
-:math:`(A \, et\, non \, B) \, ou\, (non \, A \, et\, B)`.
+:math:`(A \\, et\\, non \\, B) \\, ou\\, (non \\, A \\, et\\, B)`.
 
-Avec cette description, il est plus facile d'exprimer le problème avec des 
+Avec cette description, il est plus facile d'exprimer le problème avec des
 objets informatiques ce que fait le programme suivant. Il explicite ensuite
 toutes les configurations compatibles avec une règle donnée
 (mais pas toutes ensembles).
- 
+
 .. note::
 
     L'énigme d'Einstein est une énigme comme celle que résoud
     Hermionne dans le premier tome de Harry Potter
     (voir :ref:`l-enigme-hermionne`).
-    
 
 On commence par la fonction `permutation`:
 qui énumère les permutations d'un ensemble :
@@ -100,7 +99,7 @@
 
 def permutation(nb):
     per = []
-    p = [i for i in range(0, nb)]
+    p = list(range(nb))
     while p[0] < nb:
         cont = False
         for i in range(1, nb):
@@ -263,7 +262,7 @@ def genere(self):
         overrides method ``genere``
         """
         li = []
-        for i in range(0, 5):
+        for i in range(5):
             li.append([(i, self.set[0]), (i, self.set[1])])
         return li
 
@@ -282,7 +281,7 @@ def genere(self):
         overrides method ``genere``
         """
         li = []
-        for i in range(0, 4):
+        for i in range(4):
             li.append([(i, self.set[0]), (i + 1, self.set[1])])
             li.append([(i + 1, self.set[0]), (i, self.set[1])])
         return li
@@ -303,7 +302,7 @@ def genere(self):
         """
         li = []
         for j in range(1, 5):
-            for i in range(0, j):
+            for i in range(j):
                 li.append([(i, self.set[0]), (j, self.set[1])])
         return li
 
@@ -325,7 +324,7 @@ def genere(self):
         per = permutation(5)
         for p in per:
             tl = []
-            for i in range(0, len(p)):
+            for i in range(len(p)):
                 tl.append((i, self.set[p[i]]))
             li.append(tl)
         return li
@@ -337,7 +336,7 @@ def genere(self):
 
 
 def find(p):
-    for i in range(0, len(ensemble)):
+    for i in range(len(ensemble)):
         if p in ensemble[i]:
             return (p, i)
     return None
@@ -447,14 +446,14 @@ def find(self, p):
         :param p: clause
         :return: tuple (clause, position)
         """
-        for i in range(0, len(ensemble)):
+        for i in range(len(ensemble)):
             if p in ensemble[i]:
                 return (p, i)
         return None
 
     def to_dataframe(self):
         sr = []
-        matrix = [list(" " * 5) for _ in range(0, 5)]
+        matrix = [list(" " * 5) for _ in range(5)]
         for row in self.solution:
             i = row[0]
             j = row[1][1]
@@ -465,7 +464,7 @@ def to_dataframe(self):
         text = "\n".join(sr)
         return pandas.read_csv(StringIO(text), header=None)
 
-    def solve(self, solution=[], logf=print):  # solution = [ ]) :
+    def solve(self, solution=[], logf=print):  # noqa: B006
         """
         Solves the enigma by eploring in deepness,
         the method is recursive

_doc/examples/prog/plot_float_and_double_rouding.py

@@ -3,15 +3,15 @@
 ================
 Float Conversion
 ================
- 
-I came up with the following question 
-:math:`(float64)x < (float64)y \Longrightarrow (float32) x < (float32)y`?
+
+I came up with the following question
+:math:`(float64)x < (float64)y \\Longrightarrow (float32) x < (float32)y`?
 What is the probability this holds?
 
 Probability (float64)x == (float32)x
 ====================================
 
-Let's evaluate how many time we draw a random double 
+Let's evaluate how many time we draw a random double
 number equal to its float conversion.
 """
 
@@ -66,7 +66,7 @@
 # We finally check that double operations between float numpers remain floats.
 
 
-for i in range(0, 100000):
+for i in range(100000):
     i, j = random.randint(0, len(rnd32) - 1), random.randint(0, len(rnd32) - 1)
     d32 = numpy.float64(rnd32[i] * rnd32[j])
     d64 = numpy.float64(rnd32[i]) * numpy.float64(rnd32[j])

_doc/examples/prog/plot_gil_example.py

@@ -5,15 +5,15 @@
 
 ======
 Le GIL
-====== 
+======
 
 Le GIL ou `Global Interpreter Lock <https://en.wikipedia.org/wiki/Global_interpreter_lock>`_
-est un verrou unique auquel l'interpréteur Python fait appel constamment 
+est un verrou unique auquel l'interpréteur Python fait appel constamment
 pour protéger tous les objets qu'il manipule contre des accès concurrentiels.
 
 Deux listes en parallel
 =======================
- 
+
 On mesure le temps nécessaire pour créer deux liste et comparer ce
 temps avec celui que cela prendrait en parallèle.
 """
@@ -39,7 +39,7 @@ def create_list(n):
 
 def run2(nb):
     with ThreadPoolExecutor(max_workers=2) as executor:
-        for res in executor.map(create_list, [nb, nb + 1]):
+        for _res in executor.map(create_list, [nb, nb + 1]):
             pass
 
 
@@ -74,7 +74,7 @@ def attendre(t=0.009):
 
 def run3(t):
     with ThreadPoolExecutor(max_workers=2) as executor:
-        for res in executor.map(attendre, [t, t + 0.001]):
+        for _res in executor.map(attendre, [t, t + 0.001]):
             pass