See the version I wrote in 07839b2, without dictionary.
I want to understand why the dictionary-based version is not slower than the version based on list or numpy arrays.

pgbovine's PythonTutor Py3K is designed exactly for this!

A picture is worth a thousand words:

sudo pip install ocaml

Then you can use basic OCaml expressions and standard library... from IPython or Jupyter notebook with IPython kernel, without having to install OCaml yourself on your laptop!
It's pre-compiled. I don't know what version thought...

• send an email to the developer to ask him?
• it's not open-sourced and the file on Pypi only include the .cmi and .so files, so it's hard to know how he obtained this...
• it would be a great project to show to students studying Python and C and OCaml : this tiny IPython magic makes the link between Python and OCaml (one way) using OCaml compiled as a dynamic extension to CPython 😍 !

Réf: https://www.johndcook.com/blog/2018/04/11/anatomy-of-a-posit-number/ et https://www.johndcook.com/blog/2018/04/14/ieee-vs-posit/ et https://www.johndcook.com/blog/2018/04/15/eight-bit-floating-point/

Ca devrait ressembler à ce texte de 2017 sur l'arithmétique avec les flottants IEEE.

• Je peux commencer par écrire un petit notebook qui code des trucs,
• Puis voir comment écrire les questions "programmation" du texte,
• Et voir ce qu'on peut demander sur un plan théorique !

See parrt/lolviz#27 (comment)

See the notebook (work in progress)

• Include tests using the C versions of KL divergences and KLUCB ? (see here on SMPyBandits)
• Include optimized versions of the utility functions for UCBoost ? (see this issue on SMPyBandits)
• Then when happy about the content of the notebook, I could convert to a Python package on Pypi, like I did for this notebook which is now this package.

New repo

• Dans ce notebook http://nbviewer.jupyter.org/github/Naereen/notebooks/blob/master/Verification_de_numeros_CB_RIB_NIRPP_IBAN.ipynb
• Cf. cet article présente l'organisation des 15 chiffres d'un IMEI https://fr.wikipedia.org/wiki/International_Mobile_Equipment_Identity#Structure
• Et cet article explique l'origine de la création de la formule de Luhn https://spectrum.ieee.org/tech-history/silicon-revolution/hans-peter-luhn-and-the-birth-of-the-hashing-algorithm

En même temps, les probas ne sont pas favorables. (pour les numéros de téléphone premiers)

Alors en fait, environ 5.1% des numéros de téléphones mobiles français (donc entre 0600000000 et 0799999999) sont premiers !

Je croyais avoir un notebook sur ça, hm... non, donc je vais le faire !

Use iocaml.

It could be, again, a good opportunity to write the same (basic) code for a non-trivial algorithm (with visualizations) in different languages.

• See here for reference (Wikipédia)
• See these packages

Tasks:

• First read and understand the algorithm(s) again (I coded it on my TI-82 back in 2010!),
• Quickly write a Python version, with nice examples and visualizations → Runge-Kutta_methods_for_ODE_integration_in_Python.ipynb
• Then write a Julia version with same code and examples,
• Try to write a (basic) OCaml version also, hopefully with visualizations (not an issue if they only work in the notebook)
• Benchmark and compare the three implementations (possibly more: using numba or numpy/scipy in Python, using a ode package in Julia, using interpreted vs compiled vs opt-compiled OCaml code, etc)

I did some basic statistics on this data, can I try to use it again and perform some more advanced analysis, like a NLP data analysis?

Examples of question I could ask to this database:

• I my grammar better than my contacts'?
• Do I use more text based emoticons like :-) or emojis like 😄?
• Do I conclude my text with . ? ! or nothing?
• How is the length of my text messages and their content (?) evolves in the day?

Et ça me fera un TP en enlevant les solutions.
J'aimerai cette fois : définir un type abstrait pour les termes du lambda-calcul, implémenter l'alpha renommage, la réduction etc (le maximum, en restant raisonnable).
L'affichage déjà ce sera pas mal, et la conversion en fun x -> ... de Caml, pour faire (et en lambda ... de Python, ça peut être chouette) comme cet article de Matt Might en Python...

Ce poly de cours peut aider

J'ai déjà écrit la correction de ce texte d'anale d'agrég, et avec le code des élèves, je dois écrire une correction.

Like on TV or Google Street View when they blur the faces of peoples, I want to write a small Python notebook showing how to do this, with a custom pixel size, on large images.

It can probably be done with a neat function coming from skimage (see its API) or from scipy.ndimage (see its API).
But I want to implement it myself, on both gray-scaled and colored images.

Like in https://github.com/norvig/pytudes
https://deepnote.com/ is pretty cool!

I studied it in 2013, but in a French course, and from all this time I never made the connection between what I saw as simulated annealing and the algorithm seen in the class of Florian de Vuyst in 2013...

This PDF contains many details on how to get to the optimized version with O(alpha(n)) version (almost O(1)) for union and find.

I won't take the time to implement this version, but adding a link at the end of that part will suffice.

Idée :

• A partir d'un corpus de citations latines (e.g., les pages roses d'un gros dictionnaire Larousse), on veut apprendre à distinguer les locutions latines des locutions pas latines du tout.
• Autre application : un générateur automatique de pseudo citations latines, un roi Loth en quelque sorte... Voir ces citations

Approche :

• Trouver un corpus de citations latines (cette page
• Faire du traitement de données et de NLP dans un joli notebook Python,
• Donner un exemple de x phrases étant des vraies locutions latines (ou ressemblant) et y phrases étant carrément pas latines, et faire apprendre (à un réseau de neurones + NLP ?) à classifier les x comme latines et y comme pas latines,
• Ou alors, juste générer des locutions aléatoires ? (je peux aussi faire ça avec une chaîne de Markov, cf. markov.py by @jilljenn)

I was discussing with a friend, and realized that I started a few months ago to write, as much as possible, my French text messages using an inclusive writing. For example:

Tu vas voir tes amis ? → Tu vas voir tes ami-e-s ?

Ideally, I would like my keyboard to suggest me words like this.
But I'm not an Android programmer, and I don't have time to learn this (right now).
So instead, I want to write a Python notebook to showcase the following feature:

• If the keyboard suggests a word, like "amis" above, automatically decide if it's a name that should/could be written in an inclusive form,
• And for words that can have inclusive form, automatically compute it : "amis" → "ami-e-s".

Warning: there is so many exceptions, like "chevaux" is "cheval" at plurals, but feminine is "jument" so instead of "chevaux-ales" you write "chevaux/juments". Quite hard to be perfect in an automated way.

• Idée intéressante : récupérer les données de http://agreg.org/ResultatsMerite201{2..8}.html http://agreg.org/ResultatsAdm201{3..8}.html, de HTML vers texte/markdown, vers CSV, vers SQL... Et faire des stats et des requêtes croisées après (e.g., combien de candidat-es ont passés l'agrég deux ans de suite ? combien ont passés deux fois mais pas deux ans de suite ? combien ont changé d'académie entre deux tentatives ?).

• En OCaml c'est tout à fait possible, mais contrairement à Python qui propose le module sqlite3, il n'y a rien dans la bibliothèque standard. Mais il y a plusieurs options, par exemple : https://github.com/perf101/ocaml-sql qui supporte juste PostgreSQL, mais https://mmottl.github.io/sqlite3-ocaml/ et (qui est sur opam, https://opam.ocaml.org/packages/sqlite3/) supporte SQLite3. Super !

See a link like this:
https://besson.link/Basthon/notebook/?from=../../publis/notebooks/Py_Pi_Day_2017.ipynb
It works!

For most of my notebooks, using Basthon won't work because:

• I'm using other kernel than IPython: OCaml, C, Java, Rust, Julia, Bash, GNUPlot and even Octave!
• I'm using IPython magic a lot, like %timeit etc, which are not (yet) supported in Basthon (see https://framagit.org/casatir/basthon-kernel/-/issues/10).
• I'm using Jupyter notebook extensions, like itikz, lolviz, rcviz, watermark, cython, ipythonblocks, ipywidgets, etc.

But for the "pure Python" notebooks (even using numpy, matplotlib etc), I can use my locally available Basthon notebook (http://notebook.besson.link/ or https://besson.link/Basthon/notebook/) to load a notebook available from the same site.

Voir les sources, et ces articles sur des blogs du Monde, celui là ou encore celui-là.

• Faire un dépôt à part
• Un dossier pour chaque texte d'annales
• Stocker aussi les PDF, je pense avoir le droit ?
• Pour chaque texte, écrire un notebook en OCaml et en Python
• Pour certains textes, si ça s'y prête, je peux essayer une implémentation en C et en Java aussi, ça me ferait travailler ça
• Une fois bien avancé, je peux générer un site bien joli avec jupyter-book

They just take a lot of visual space in the landing page...
And are useless.

See https://github.com/Naereen/Jupyter-Notebook-Atom-Scheme#actually-dont-use-this-use-jupyter-themes-instead

• I should use jupyter-themes but only to change the fonts and basic setting, not use their theme.
• I should use Palatino and TeX Gyre Pagella for serif font, Lato Sans or Ubuntu Sans for sans-serif font, and of course Fira Code for monospace. (like I no do for Marp slides)
• and regenerate all HTML versions

Pour l'instant : https://github.com/Naereen/notebooks/blob/master/agreg/public2018_D2.ipynb

• Mieux comprendre ces opérateurs oplus et omul
• Voir pour implémenter un "bonus" aussi
• Ou une visualisation sympa ?

Références

1. Vidéo présentation Rush hour https://www.youtube.com/watch?v=m_A3ENh2g34
2. https://stackoverflow.com/questions/2877724/rush-hour-solving-the-game
3. article sur l'aspect P-SPACE complete et comment faire des portes logiques avec Rush Hour http://groups.csail.mit.edu/mac/users/bob/sliding-blocks.pdf
4. Plank Puzzle http://clickmazes.com/planks/ixplanks.htm (inventé par une dame passionnée de puzzle).
5. Ce solveur, https://github.com/fogleman/rush
6. Ce post de blogue, https://www.michaelfogleman.com/rush/

Tâches

• Implémenter un solveur brute-force pour le jeu, et un vérificateur de solution,
• Rédiger une réduction à la main, vérifier que c'est du niveau agrég,
• (bonus) Implémenter une visualisation interactive d'une solution...
• Commencer à rédiger un exemple de solution dans un notebook, et s'il y a assez de contenu (je pense), commencer à rédiger un texte type modélisation.

When I wrote this new version of CP, I was happy to add --csv-exclude and --exclude=.git and --exclude-from=.gitignore options...

But as a results, the .html and .pdf versions of the notebooks are no longer automatically sent to this folder on my website...
I don't know how to have both a git-safe send rule and an inclusive send rule to send HTML/PDF files.

If I write something like:

send:
        CP ./*.html ./**/*.html ${Szam}publis/notebooks/

then it works for 0-depth files, but for files in sub-directories, they end up on the root directory of the target...

• On Binder
• On DeepNote
• On Google Colab

I have a small comment regarding: Runge-Kutta_methods_for_ODE_integration_in_Python
I know, you uploaded the notebook 6 years ago, but I still think it is a nice little resource to play around with. If you change the decorator from @jit to @njit, numba is prevented from going into "python-mode" meaning it cannot fall back to simply not compiling the runge-kutta-method. In this way you can see that you need to also compile pend() and f() with numba because a numba compiled function can only take numba compiled functions as arguments:

Time of solving this ODE for 100 points with odeint method...
143 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
Time of solving this ODE for 100 points with rungekutta4_jit method...
66.3 µs ± 2.38 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

If you would add this small comment, I would be really glad, if not, feel free to delete this issue.

I was reading this article [Perturbed-History Exploration in Stochastic Multi-Armed Bandits, by Branislav Kveton, Csaba Szepesvari, Mohammad Ghavamzadeh, Craig Boutilier, 26 Feb 2019, arXiv:1902.10089].

They propose an algorithm, called PHE, to tackle the classical (stationary) Multi-Armed Bandit problem. PHE works by adding $O(t)$ pseudo-rewards at the current time step $t$.
To justify that their idea of adding $t$ samples at each time does not increase the computation time of their proposal (it has to stay $O(1)$ at each time step, to be competitive with other approaches like UCB, klUCB or Thompson Sampling), they give the following explanation.

1. Their first claim is that generating the sum of $t$ samples from a Bernoulli distribution $B(\frac{1}{2})$ (of mean $1/2$) is equivalent to generating a sample from a Binomial distribution $Bin(t, \frac{1}{2})$. It is obvious by definition, so I agree.
2. Their second claim is that one can generate this unique sample from a Binomial $Bin(t, \frac{1}{2})$ in a constant time $O(1)$. It is not obvious, and not justified. I disagree.

I disagree for their second claim because, up to my knowledge, the best method to generate samples from a non-degenerated Binomial distribution is a method by Luc Devroye (explained in chapter 10 of his book), based on the inversion method (inverse transform sampling), as explained on the Wikipedia page, for instance.

• I want to write a small Jupyter notebook that implements this method manually, in Python as well as in Cython, to show that it works as well as numpy.random.binomial, and that its computation time does increase (in average) when $t$ increases.
• I will then write a quick email to the authors. ==> I was wrong!