Python | Dr. Goulu

Les finesses de Python

Sat, 23 Jun 2018 00:00:00 +0000

J’ai donné une petite conférence au sur certains aspects “avancés” du langage Python :

Générateurs, iterateurs et programmation fonctionnelle
Introspection
Décorateurs
- exemples : Memoïsation et Timeout
- Prédéfinis et “multiméthodes”

J’avais utilisé un “notebook ” comme support, et je viens de , alors voilà:

l’erreur à la fin est normale, si vous avez bien suivi…

Le repo du document est ici : https://github.com/goulu/python_finesses

A303935 , ma première suite OEIS

Sat, 09 Jun 2018 00:00:00 +0000

Depuis le temps que je joue avec l’ ( ), ça a fini par arriver : j’ai réussi à y ajouter une nouvelle suite, !

Tout a commencé avec le , qui traite de la somme des factorielles des chiffres (dfs) des nombres ( ). Seuls quatre d’entre eux appelés sont égaux à la somme des factorielles de leurs chiffres : 1, 2, 145 et 40585 ( ).

Quelqu’un a prouvé en 2004

\[1\]

que l’application répétée de la fonction dfs atteint immanquablement un des 4 factorions ou l’une des trois seules et uniques “boucles” suivantes:

169 → 363601 → 1454 → 169 871 → 45361 → 871 872 → 45362 → 872

Ne restait plus qu’à compter la longueur de l’ de dfs(n), et c’est précisément ce que liste , qui n’était pas encore répertoriée dans l’OEIS.

Publier dans l’OEIS, c’est du sérieux.

Le processus de publication dans l’OEIS est très strict, sur le modèle de certaines publications scientifiques. “The standards are those of a mathematics reference work.” comme ils le mentionnent.

Après s’ il faut préparer tout le contenu comme pour un “papier”, en citant d’autres séries liées et des publications scientifiques. Ensuite des “reviewers” ne se privent pas de demander des précisions et clarifications, voire de corriger la ponctuation… C’est vraiment strict, et ça peut prendre un mois, qui a nécessité 40 itérations avant publication.

J’ai failli abandonner car l’édition de m’avait plutôt fait imaginer un processus collaboratif à la Wikipédia. Puis je me suis dit que puisque “ma” suite était connue depuis quelques années mais pas publiée dans l’OEIS, mes prédécesseurs avaient du se décourager, mais qu’il fallait que quelqu’un se sacrifie, alors voilà :

2, 1, 1, 16, 8, 10, 15, 32, 36, 35, 2, 2, 17, 33, 13, 10, 15, 32, 36, 35, 17, 17, 9, 37, 7, 12, 6, … telle est désormais ma suite d’entiers préférée.

Et une référence “peer reviewed” de plus

\[2\]

Et en Python ?

Le code suivant, tiré de , implante les trois suites mentionnées en Python, à l’aide de la .

\[python\]

def dfs(n): return sum(map(factorial,digits(n)))

A061602=Sequence(0, dfs, desc=“Sum of factorials of the digits of n”)

A014080=Sequence(0,None,lambda n:dfs(n)==n)

def dfcl(n): l=set() i=n while i not in l: l.add(i) i=dfs(i) return len(l)

A303935=Sequence(0,dfcl) )

\[/python\]

Ce code est suffisant pour calculer quelques milliers de termes de A303935, mais pour résoudre le problème 74 rapidement, il faut être légèrement plus subtil… Comme je ne donne pas de solutions aux Problèmes Euler, je vous laisse chercher…

En passant, ce problème était mon 100ème résolu, ce qui fait que je suis passé “Level 4 " !

Référence

\[altmetric doi="10.1017/S0025557200174996" float="right"\]Gupta, S. S. (2004). 88.31 Sum of the factorials of the digits of integers. The Mathematical Gazette, 88(512), 258–261. DOI>
Ph. Guglielmetti, Sequence in The On-Line Encyclopedia of Integer Sequences (2018), published electronically at .

Suites infinies en Python

Mon, 26 Jun 2017 00:00:00 +0000

Depuis que je programme en Python, j’entasse les petits bouts de code utiles ou potentiellement réutilisables dans “Goulib”, ma librairie perso et néanmoins disponible en open-source (licence LGPL) sur , , ReadTheDocs pour , avec des

Comme la valeur d’un code se mesure surtout par les tests qui vérifient son bon fonctionnement, je me suis lancé dans un ambitieux projet (de plus…) : tester un maximum de fonctions de mes modules et en calculant des suites de l’ , plus connue sous son acronyme anglais OEIS.

Pour cela j’ai fait un truc dont je suis vachement fier* :

La classe Sequence

Ce ( ) permet de représenter une (sequence en anglais) finie ou infinie de nombres** à partir d’‘une ou plusieurs fonctions passées à :

iterf : un ou générateur produisant les termes de la suite l’un après l’autre
itemf : une fonction retournant le i-ème paramètre de la suite
containf : une fonction renvoyant vrai (True) si son paramètre appartient à la suite.

On peut créer par exemple la série (infinie) des nombres premiers ainsi :

=Sequence(containf= )

Ensuite, l’objet ainsi créé avec n’importe quelle combinaison de ces 3 paramètres peut être utilisé indifféremment:

comme un générateur : for p in A000040() : print(p) # affiche les nombres premiers (jusqu’à l’infini)
comme une liste: A000040 \[999\]# renvoie le 1000ème nombre premier (parce que Python indice à partir de 0…)
comme un ensemble: 201420142013 in A000040 # renvoie True car ce nombre est premier.

Evidemment, si on dispose de fonctions plus efficaces pour chacun de ces paramètres, on peut les utiliser pour rendre les calculs bien plus rapides. Par exemple pour la suite de Fibonacci, on peut exploiter trois algorithmes différents :

=Sequence(iterf= , itemf= , containf= )

En passant, voici comment est définie la séquence “auto descriptrice"qui orne la bannière de l’OEIS ci-dessus:

=Sequence( ( lambda x: ( ( ( ( (x))))) ,1))

Compact et presque clair, non ?

Dérivation

Une Sequence peut être dérivée d’une autre grâce à plusieurs méthodes:

renvoie une Sequence correspondant à la Sequence source filtrée par une fonction. Par exemple: =A000040.filter( ) renvoie les “exposants de Mersenne”, les nombres premiers p tels que $2^p - 1$ est premier.
applique une fonction à chaque terme de la Sequence source. Par exemple la série des carrés des nombres premiers peut se définir ainsi: =A000040.apply(lambda n:n*n)
Pour éviter l’utilisation d’apply dans des cas trivialement simples, l’addition (et la soustraction) d’une Sequence et d’un entier sont définies. Par exemple: = +1 définit les à partir des nombres de la forme $2^{2^n}$
renvoie une Sequence dont le n-ième terme est obtenu en sommant les n premiers termes de la Sequence source: =A000040.accumulate()
renvoie une Sequence produite en appliquant applique une fonction à chaque paire de termes consécutifs. Ainsi la suite des différences entre nombres premiers consécutifs s’écrit: =A000040.pairwise(operator.sub)

On peut aussi combiner deux Sequences pour en créer une nouvelle:

L’opérateur % (modulo, pourquoi pas…) renvoie les termes de la Sequence opérande de gauche qui ne sont PAS dans l’opérande de droite. Ainsi: =A000040 % définit la Sequence des nombres premiers qui ne sont pas
L’opérateur & (and) renvoie les termes de la Sequence opérande de gauche qui sont aussi dans l’opérande de droite. Ainsi: = & A000040 définit la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1.
L’opérateur | (or) renvoie la fusion de deux séquences à l’aide du génial . Ainsi: = | définit les nombres ayant 4 diviseurs (dont 1 et eux-mêmes) comme l’union de ceux qui sont le produit de deux nombres premiers avec ceux qui sont le cube d’un nombre premier.

Il y a encore deux méthodes un peu “tirées par les cheveux” du point de vue mathématique, mais qui fonctionnent très bien informatiquement:

renvoie une Sequence (par défaut) en triant les termes de la Sequence d’origine. Par exemple, voici la suites des surfaces des dans l’ordre croissant: =Sequence(math2.primitive_triples).apply(lambda x:x \[0\]*x \[1\]//2) .sort()
renvoie une Sequence où les termes redondants de la suite d’origine sont absents, par exemple: = .unique() // oui, parce que le 5 appartient à deux paires de nombres premiers jumeaux …

Ces méthodes utilisent respectivement et qui fonctionnent tant que la suite initiale est “presque” triée, à savoir tant que l’écart n entre un terme $a_i+n \leq a_i$ n’excède pas le paramètre “buffer” de la fonction. On peut évidemment trouver des suites qui ne pourront “mathématiquement” pas être traitées ainsi, mais informatiquement j’arrive à reproduire les suites de l’OEIS rencontrées jusqu’ici avec buffer=100 seulement

Le dictionnaire OEIS

J’ai ainsi constitué peu à peu le fichier qui définit actuellement environ 150 séries de l’OEIS, et que j’étoffe lorsque l’occasion se présente. A la fin de ce module, j’utilise la géniale possibilité d’introspection de Python pour regrouper toutes les Sequence définies dans un dictionnaire fort utile pour les tests:

\[python\]

# Construit le dictionnaire OEIS par introspection : Simple et WOW ! oeis={} # on crée le dictionnaire vide seqs=globals().copy() # on copie tous les objets déclarés dans ce module for id in seqs: # on parcourt tous les identificateurs des objets if id

\[0\]

==‘A’ and len(id)==7: # et s’ils ont un nom de séquence OEIS … oeis

\[id\]

=seqs

\[id\]

# on les ajoute au dictionnaire … seqs

\[id\]

.name=id # et on définit leur champ name

\[/python\]

Performance

Un point important est qu’aucun calcul n’est effectué lors des opérations ci-dessus. Ce n’est qu’au moment d’utiliser les Sequence ainsi définies que les fonctions iterf, itemf, containf et leurs éventuelles compositions sont évaluées.

C’est un peu “automagique”, mais il faut tout de même veiller à utiliser les algorithmes les plus efficaces, et c’est même un des buts que je poursuis avec ce projet. Par exemple la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1 = & A000040 aurait pu s’écrire également: A020449=A000040 & A007088 mais la première formulation est beaucoup plus rapide car la série A007088 des nombres ne s’écrivant qu’avec des 0 et des 1 croît beaucoup plus vite que celle des nombres premiers A000040. Il est par conséquent beaucoup plus rapide de tester si les nombres du genre 1101010101011101 sont premiers que d’énumérer tous les nombres premiers de 16 chiffres et de jeter ceux qui contiennent d’autres chiffres que des 0 ou 1.

Malgré toutes ces précautions, parcourir une suite infinie prendra forcément un temps infini, et ces idiots d’ordinateurs ne sont toujours pas foutus de gérer le . J’ai donc écrit un qui limite le temps de calcul d’une boucle ainsi :

for x in (suite,1): print(x) # affiche tous les termes calculables en 1 seconde (au total)

Ce décorateur est utilisé en particulier dans la fonction appelée par pour afficher les dix premiers termes d’une Sequence, ou du moins ceux qu’on peut calculer en moins d’une seconde.

Les suites particulièrement lentes sont par exemple ou dont le n-ième terme donne le nombre de nombres inférieurs à 10^n satisfaisant une certaine condition. Faute de meilleur algorithme, chaque terme prend 10x plus de temps que le précédent …

Tests

Voià, tous les ingrédients sont prêts pour tester si mes beaux algorithmes fonctionnent correctement, ce qui était le but initial je le rappelle.

Pour ceci, il suffit de vérifier que chaque Sequence fournit bien les mêmes termes que ceux disponibles dans l’OEIS. Ceci est facilité par le fait que l’OEIS fournit pour chaque suite les n premières valeurs dans un fichier texte en accessible par le web. Par exemple fournit les 10'000 premiers nombres premiers.

Donc mon fichier est lui aussi génialement simple* : il traverse le dictionnaire oeis et pour chaque Sequence il télécharge les N termes de référence du site OEIS, vérifie que les n premiers termes de la Sequence sont bien ceux attendus, et produit une erreur sinon. Ou un avertissement si itimeout a limité n à moins de 10.

Ces tests sont automatiquement exécutés (avec beaucoup d’autres) chaque fois que je pousse une nouvelle version de , ce qui fait que je suis averti si modification crée un problème avec une ancienne version de Python ou si un Pingouin détecte un problème invisible de mes Fenêtres.

Débogage… de l’OEIS !

J’ai ainsi beaucoup débogué, amélioré et optimisé la plupart des fonctions de et beaucoup d’ , et je compte poursuivre dans cette voie qui permet d’utiliser les données de l’OEIS comme une référence, validées par de nombreux utilisateurs.

Sauf que des fois, le bug était chez eux. Et je ne suis pas peu fier d’ sur l’OEIS :

, comme déjà mentionné dans , le 20ème terme de la série est 145, pas 142.
, dont certains termes avaient besoins de 0 supplémentaires. Tant qu’à faire j’ai fourni un B-file contenant les 1000 premiers termes exacts pour remplacer l’ancien qui n’en avait que 500.

A cette occasion j’ai remarqué que l’édition de l’OEIS est un peu rébarbative, ce qui peut décourager les contributeurs débutants. Peut-être que mon modeste projet pourrait servir de base à un site plus interactif, utilisant du code (Python of course) pour calculer dynamiquement les suites requises …

Ce long article mijoté pendant plus de six mois se termine par un appel aux allumés du code bonnes volontés : si cet article vous a motivé , n’hésitez pas à contribuer à la Goulib sur GitHub.

Pour ma part je m’attaque aux et qui seront l’occasion de nettoyer le code du en utilisant et testant le module

Notes

*sinon je n’en parlerais pas ici… **ou d’autres objets mais je n’ai pas encore trouvé quoi…

Comment calculer le 10'000'000'000'000'000'000 ème terme de la suite de Fibonacci

Tue, 25 Apr 2017 00:00:00 +0000

Tombé l’autre jour sur un problème idiot mais intéressant : calculer le 1019 ème terme de la . Idiot parce que ça ne sert à rien. Intéressant parce que ça sous-entend qu’il existe une manière de calculer le n-ième terme de cette suite définie par récurrence sans calculer tous les termes précédents. En effet, calculer les termes les uns après les autres prendrait dans les 300'000 ans à raison d’une microseconde par terme…

Un nombre d’or, mais flottant

Comme même les ésotéristes le savent, la suite de Fibonacci est liée au A partir de ce fait, Moivre, Euler et Binet ont indépendamment obtenu ce qu’on appelle aujourd’hui la , et qui donne directement le n-ième terme de la suite:

$\mathcal F_n=\frac1{\sqrt5}(\varphi^n-\varphi'^n)$, avec $ \varphi=\frac{1+\sqrt5}2$, et $ \varphi'=-\frac1\varphi$ .

En pratique, le terme en $ \varphi'$ devient rapidement négligeable et il suffit de chercher l’entier le plus proche de $\frac{\varphi^n}{\sqrt5}$. Par exemple pour n=50, on peut calculer très vite $\mathcal F_{50}\approx\frac{\varphi^{50}}{\sqrt5}$ = 12586269025

Mais on se heurte rapidement au problème de la précision de calcul en nombres flottants sur nos ordinateurs : $\varphi$ étant (mais pas aussi que $\pi$ …), il faut calculer $\varphi^n$ avec au moins autant de décimales que $\mathcal F_n$ comporte de chiffres. Dès n=71 on dépasse les 53 bits de la mantisse des nombres “extended precision” et les dernières décimales des termes calculés sont faux.

Dit autrement, à partir de n=70 la division $\mathcal F_n/\mathcal F_{n-1}$ donne au moins autant de décimales de $ \varphi$ que son calcul en nombres flottants

La Matrice salvatrice

Pour une méthode de calcul en nombres entiers atteignant (presque) la rapidité de la formule de Binet, il faut utiliser l’idée d’un certain Brenner : écrire la récurrence de Fibonacci sous forme matricielle . La matrice toute simple $Q=\begin{pmatrix}1&1\\\\1&0\end{pmatrix}$ permet d’obtenir un nouveau terme de la série de Fibonacci en la multipliant par un vecteur formé des deux termes précédents:

$\begin{pmatrix}1&1\\\\1&0\end{pmatrix}\begin{pmatrix}\mathcal F_{n-1}\\\\\mathcal F_{n-2}\end{pmatrix}=\begin{pmatrix}\mathcal F_{n}\\\\\mathcal F_{n-1}\end{pmatrix}$

En enchaînant les multiplications matricielles, on obtient le n-ième terme à partir des deux premiers (0,1) ainsi :

$\begin{pmatrix}1&1\\\\1&0\end{pmatrix}^{n-1}\begin{pmatrix}1\\\\0\end{pmatrix}=\begin{pmatrix}\mathcal F_{n}\\\\\mathcal F_{n-1}\end{pmatrix}$

En fait on retrouve les termes de la suite directement dans la matrice $Q^n = \begin{pmatrix}\mathcal F_{n+1}&\mathcal F_{n}\\\\\mathcal F_{n}&\mathcal F_{n-1}\end{pmatrix}$.

L’algorithme de l’ permet d’élever la matrice Q à la puissance n en effectuant log2(n) multiplications de matrices 2x2, soit pour n=1019. Ultra rapide, et facilement généralisable à d’autres formules de récurrence !

Malheureusement, la fonction souffre d’une qui empêche de l’utiliser dès n=71 car elle utilise les nombres flottants. Il m’a donc fallu la réécrire, en résolvant une petite contrainte technologique au passage.

Vers les pétaoctets et au delà …

Il se trouve que le 1019-ième terme de la suite de Fibonacci est trop grand pour tenir dans le plus super des ordinateurs. En effet, la longueur du n-ième terme de la suite s’obtient facilement en prenant le log (base 10) de la formule de Binet : $\mathcal L_n=\lceil n\log{\varphi}\rceil$ , soit grosso-modo n*0.208987640249978733769272089237555416822459239918210953539…

Vérifions. Pour n=1000, on obtient:

$\mathcal F_{1000}$=43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875 qui comporte bien pile 209 chiffres.

Donc $\mathcal F_{10^{19}}$ comporte 2089876402499787337 chiffres … Il faudrait octets de RAM (de préférence…) pour stocker ce nombre …

(mon premier meme … désolé …)

Et modulo 1000000007 ?

Fort heureusement, le problème idiot avait un petit détail en prime : il fallait calculer le résultat 1000000007, et ça, ça change tout.

Ce nombre est premier (pour que ça soit plus intéressant), mais surtout il est inférieur à 230, ce qui fait que la multiplication modulo 1000000007 ne nécessite que des opérations sur des 32 bits (signés), ultra rapide.

Voici donc quelques fonctions Python tirées du qui effectuent:

le produit matriciel, optionnellement modulaire
l’exponentiation rapide d’une matrice, optionnellement modulaire, et qui corrige le bug de numpy.matrix_power
le calcul quasi instantané du n-ième terme de la série de Fibonacci, avec une option modulaire vivement recommandée pour de grands n

\[gist id="f56725fa32fbb4840c855a8309662c9d"\]

Avec ça on obtient fibonacci(int(1E19),1000000007) = 647754067 ce qui nous fait une belle jambe, mais nous a appris pas mal de choses intéressantes, non ?

Prochaine étape : trouver la correspondante …

Références

sur StackOverflow (et qui m’a inspiré cet article)
Weisstein, Eric W. “ .” From MathWorld–A Wolfram Web Resource.
Arthur Charpentier “ , 2016 sur Freakonometrics (mention spéciale pour l’image de la spirale…)

2017 et les triplets pythagoriciens

Mon, 02 Jan 2017 00:00:00 +0000

Au moment d’envoyer un mot à Franck à propos de son livre , je me suis rappelé qu’il était à l’origine de sur la pédagogie appliquée au théorème de Pythagore (et aussi de sur la Relativité). J’ai ainsi découvert celle des sur laquelle baser mes vœux pour cette nouvelle année :

Bonne et Heureuse Année $\sqrt{792^2+1855^2}$ !

En effet, 2017 est un “nombre hypotenuse” ( ), l’hypoténuse du triangle rectangle correspondant au (792,1855,2017). C’est même un triplet pythagoricien “primitif” car ces 3 entiers sont , donc 2017 est un “nombre hypoténuse primitif” ( ).

(3,4,5), le premier et le plus célèbre des triplets pythagoriciens

Car comme on le voit dans , il existe deux sortes de triplets pythagoriciens: les et les composés, qui sont des multiples de triplets plus petits, par exemple (6,8,10) obtenu en doublant (3,4,5). Ca va avoir de l’importance plus bas.

Comment générer les triplets pythagoriciens

Il existe plusieurs algorithmes simples pour générer des triplets pythagoriciens. Ils sont tous mauvais. Ceux qui utilisent deux boucles imbriquées voire trois sont lents, ceux qui calculent la racine carrée en nombres flottants sont imprécis, et tous sont limités par une longueur maximale des côtés recherchés. écrit pour résoudre du ne faisait pas exception.

J’ai depuis découvert l’existence d’une méthode beaucoup plus efficace, mais pas simple. Quelques millénaires après et la , en 1934 pour être précis, un matheux nommé Berggren a démontré que chaque triplet primitif pouvait être généré à partir de (3,4,5) en le multipliant par une combinaison de ces 3 petites matrices :

$R_1 =\begin{pmatrix} 1 & -2 & 2 \\\\ 2 & -1 & 2 \\\\ 2 & -2 & 3 \\\\ \end{pmatrix}$ $R_2 =\begin{pmatrix} 1 & 2 & 2 \\\\ 2 & 1 & 2 \\\\ 2 & 2 & 3 \\\\ \end{pmatrix}$ $R_3 =\begin{pmatrix} -1 & 2 & 2 \\\\ -2 & 1 & 2 \\\\ -2 & 2 & 3 \\\\ \end{pmatrix}$

Un autre matheux nommé Barning ayant montré en 1963** que chaque triplet n’est ainsi produit que d’une et une seule manière , il suffit de parcourir l’ formé en multipliant chaque nœud par chacune de ces 3 matrices pour générer l’un après l’autre tous les triplets primitifs:

Ensuite, un autre bout de code peut multiplier chaque triplet primitif par 2,3,4,… pour ajouter les triplets composés et produire ainsi tous les triplets pythagoriciens l’un après l’autre. C’est ce que fait très efficacement ce .

Oui mais dans l’ordre svp

Une difficulté supplémentaire apparaît si on veut obtenir les triplets triés dans un ordre croissant, par exemple de leur hypoténuse, puis du long côté comme dans ou dans et d’autres séries de l’OEIS. Evidemment, si on ne s’intéresse qu’aux N premiers triplets, on peut toujours les générer, et les trier ensuite. Mais si on veut chercher par exemple le plus petit triplet dont la longueur de hypoténuse est un carré ainsi que la somme des côtés*, on ne connait a priori pas N…

Pour générer les triplets dans un ordre croissant, j’ai incorporé le tri aux fonctions précédentes à l’aide de , mais je ne vais pas accentuer votre mal de cheveux annuel en vous détaillant ça ici. Pour ceux que ça intéresse, de ma librairie Goulib dont je vous reparlerai très bientôt, et où vous pouvez voter pour moi…

Mais bon, juste parce que j’en suis assez content, en testant mon code j’ai découvert une erreur dans : le 20ème terme de la série est 145, pas 142. Et j’ai ainsi pu constater que l’OEIS est un bon site scientifique car il est doté d’un système rigoureux mais efficace de correction des erreurs.

Pour terminer, à tous ceux qui se demandent à quoi peut bien servir tout ça, je recommande la lecture de auquel je n’ai pas tout compris (séquelles du champagne je suppose), mais qui propose une nouvelle méthode de cryptographie basée sur les triplets pythagoriciens.

Comme quoi les années passent, mais les bonnes idées restent et construisent inéluctablement un monde plus intéressant à découvrir.

Mes chers lecteurs, je vous souhaite à tous l’indispensable Santé, le très important Bonheur, et l’Etonnement qu’apportent la curiosité, la découverte et la compréhension de ce monde étrange.

Notes:

* C’est (4565486027761, 1061652293520, 4687298610289=21650172), découvert en 1643 par . (edit du 9.1.2016 :) dont je n’ai aucune idée de comment il a fait à l’époque spectaculaires, d’autant que la recherche avec le générateur proposé dans cet article prend des plombes… vaut décidément bien mieux, et en plus indique .

** Excellente année aussi…

Références:

Franck Le Vallois (2016). L'expérience humaine: Regard sur une métamorphose inachevée. Gouvernances.
Berggren, “Pytagoreiska trianglar”, 1934, Tidskrift för elementär matematik, fysik och kemi, vol. 17, p. 129-139.
Barning, F. J. M. “Over pythagorese en bijna-pythagorese driehoeken en een generatieproces met behulp van unimodulaire matrices”, 1963 Math. Centrum Amsterdam Afd. Zuivere Wisk. ZW-011: 37, ( )
Spezeski, W. J. “ ”, 2008, Applications and Applied Mathematics: An International Journal, 3(1), 100–112. Retrieved from

Couleurs, Gamuts, Python et Open Source

Fri, 30 Sep 2016 00:00:00 +0000

Ce fut une excellente journée de travail, stimulante et productive. Tôt le matin, Cédric m’a montré les slides d’un article sur la mesure géométrique de la différence entre deux , en me demandant s’il était facile de programmer la méthode présentée

Avant d’attaquer la question et la réponse, une petite introduction sur le merveilleux monde des couleurs s’impose.

Couleurs et gamuts

En imprimerie, on mesure à l’aide d’un l’ensemble des couleurs produites par une imprimante, ne serait-ce que pour la calibrer . Mais lorsqu’on développe une imprimante industrielle, il faut en plus mesurer l’effet sur les couleurs de nombreux paramètres (qualité des substrats, composition des encres, puissance des séchoirs etc. ) afin de maximiser le “volume” des couleurs que l’imprimante est capable de reproduire.

cube des couleurs RGB (Red Green Blue)

L’ensemble des couleurs définit un volume car il faut trois paramètres pour déterminer une couleur. La représentation la plus connue est celle basée sur les rouge, vert et bleu, le “RGB”. Sur votre écran, des pixels rouges, verts et bleus peuvent être allumés avec des intensités variables, habituellement codée par un entier entre 0 et 255. La permet ainsi de vous faire percevoir 16'777'216 couleurs différentes définies par autant de points dans le cube ci-contre.

De même, on peut faire un cube “CMY” avec les couleurs produites par en déposant des encres cyan, magenta et jaune sur du papier supposé blanc.

Oui mais voilà, comme vous vous en apercevez chaque fois que vous imprimez des photos à la maison, on n’obtient pas les mêmes couleurs en RGB et en CMY. Les deux cubes ne se superposent pas bien. Intuitivement, on comprend qu’un écran ne peut pas être plus noir que quand il est éteint, et qu’on ne peut pas rendre le papier plus blanc qu’il ne l’est originellement. Le même raisonnement s’applique aux autres directions de l’espace des couleurs : certaines couleurs possibles en RGB ne peuvent pas être obtenues en impression CMY, et vice-versa. C’est d’ailleurs pour ça que les imprimantes photo ont des couleurs supplémentaires, souvent du “magenta clair” et du “cyan clair” pour mieux imprimer vos couchers de soleils. Et aussi du noir, mais c’est plutôt pour imprimer du plus joli texte et économiser de l’encre des 3 autres couleurs.

Les couleurs que l’on peut reproduire fidèlement se trouvent dans l’intersection des deux cubes, mais les axes des deux cubes ne sont pas les mêmes, alors comment faire ?

En les représentant dans un autre espace de couleurs, plus vaste, le . Dans cet espace, la coordonnée L* correspond à la et les coordonnées a* et b* à des échelles entre couleurs tenant compte de la sensibilité de l’oeil humain. En LAB, le cube CMY d’une imprimante donnée devient un patatoïde comme celui représenté ci-dessous, et le cube RGB d’un écran précis devient le volume enfermé dans le treillis. Comme on le voit, l’intersection des deux est un volume compliqué, nettement plus petit que chacun des patatoïdes.

Gamut d’une imprimante (solide) et d’un moniteur (treillis). Image : Michael J. Vrhel

Retour au Code

Bon mais alors, est-ce qu’on peut faire facilement un programme qui calcule l’intersection de deux gamuts quelconques ? Dans ces cas là la réponse standard est “ça dépend” :

si le code Matlab décrit dans l’article est disponible, c’est tout cuit. Et peut-être même gratuit si suffit.
sinon (je n’ai pas trouvé le code…), ça dépend de l’existence de librairies (Python de préférence) effectuant les opérations délicates:
- Lire les fichiers produits par le : pas de problème car ce sont des .txt avec les valeurs LAB des quelques dizaines de couleurs mesurées
- Obtenir l’ * des points : pas de problème non plus. J’avais déjà utilisé la fonction basée sur la librairie . C’est d’ailleurs la même qu’utilise la fonction Matlab . Et elle fournit même le volume du en prime!
- Par contre, je n’ai aucune idée de comment calculer l’intersection des deux polyèdres / gamuts. Ou plutôt si : je sais que si je ne trouve pas du code faisant ça vite et bien, je vais passer longtemps à le faire mal. En gros il faut calculer l’intersection de la surface en fil de fer avec la surface colorée dans l’image ci-contre, et vice-versa. L’algorithme le plus simple qui vient à l’esprit est de vérifier si chaque côté des petits triangles formant une surface intersecte un (ou deux …) triangles formant l’autre surface, puis de refaire une enveloppe convexe de tous points d’intersection. Comme tout algo simple, il y en a probablement un bien plus efficace quelque part …

En cherchant un peu, je tombe sur la solution : , un package Python capable de faire des “Boolean operations on meshes (intersection, union, difference)”. Je l’installe, je code le gros de l’application, et exactement une heure après avoir attaqué le problème, je vois le volume de mes gamuts s’afficher ! mais l’appel à la fonction calculant l’intersection crashe…

C’est la saison des châtaignes : débogage

d’abord il faut installer , un wrapper Python de . J’avais déjà rencontré cette librairie permettant de trouver rapidement les points les plus proches d’un autre en utilisant la structure d’ mais n’étais pas sur d’en avoir vraiment besoin. Un message d’erreur me dit que si… Sur une machine Windows, cette librairie ne s’installe pas “toute seule”, il faut aller la chercher sur la fabuleuse page “ ”
ensuite je découvre pourquoi la phrase “Boolean operations on meshes (intersection, union, difference)” avait une suite : “if or is installed”. En fait, trimesh appelle l’un ou l’autre de ces logiciels pour faire le vrai boulot. Connaissant l’existence des deux, mais ayant joué avec Blender il y a quelques années et me souvenant qu’il utilise Python comme langage de script, j’opte pour Blender et …
… le code tourne ! Mais me renvoie toujours un volume de l’intersection de mes gamuts nul. Ce sont les temporaires que trimesh crée qui sont encore ouverts lorsque Blender y accède. Bizarre, parce que pour effectuer des tests automatiques et que ceux-ci ne montrent aucun problème … Mais les tests tournent sur une machine (virtuelle) Linux ! Apparemment, un pingouin a le droit de lire un fichier qu’un autre pingouin a laissé ouvert, mais une fenêtre doit être refermée avant qu’elle puisse être réouverte… Je vais devoir modifier le code de trimesh pour corriger ça, et je décide de le faire bien.

L’Open Source, c’est bon pour le business

En effet, je ne sais pas si vous avez tout suivi mais je travaille dans une entreprise qui vend des machines pour gagner du pognon et payer quelques salaires en passant. Or tous les logiciels utilisés pour développer cette application relativement pointue en une seule journée sont “ ”, gratuits. La moindre des choses est, me semble-t-il, de renvoyer parfois l’ascenseur partageant les améliorations que j’apporte à ces logiciels, évidemment dans la mesure où ça ne va pas à l’encontre des intérêts de mon employeur.

J’ai donc de , modifié qui gère les fichiers temporaires et hop ! l’application fonctionne après grosso-modo 4 heures de boulot et 4 cafés. Et comme de trimesh passent toujours (sur Linux), je soumets une “ ” à l’auteur de trimesh pour lui proposer d’incorporer mes changements à la branche officielle : B.A. accomplie en une heure supplémentaire à tout casser.

Après ça il me restait encore un moment pour implanter une idée qui m’avait traversé l’esprit : compter combien de sont incluses dans chaque gamut (et donc possible d’imprimer avec notre machine), et lister celles qui n’y sont pas. Mais comme les valeurs Lab de ces couleurs sont protégées par copyright, je ne pourrai pas mettre ce code à disposition en Open Source. Des centaines de milliers de lignes de code testé et performant oui, mais une table de couleurs, non…

Note* : ce qu’il y a de bien en écrivant un article, c’est que ça met les idées en place, ou que ça instille un léger doute. En regardant les polyèdres des gamuts RGB et CMY dans LAB, on voit qu’ils ne sont pas convexes… Pour être plus précis, peut-être bien qu’il me faudrait utiliser un algo plus subtil que ConvexHull …

Références:

Deshpande, K., Green, P., & Pointer, M. R. “Metrics for comparing and analyzing two colour gamuts”, 2015, Color Research & Application, 40(5), 465–471. ( )
Arnaud Frich “Guide de la Gestion des Couleurs - ”, 2016
Barber, C.B., Dobkin, D.P., and Huhdanpaa, H.T., “The Quickhull algorithm for convex hulls,” ACM Trans. on Mathematical Software, 22(4):469-483, Dec 1996,
Vrhel, M. J., & Trussell, H. J. “ ”, 1999, IEEE Transactions on Image processing, 8(12).
Beckmann, N., & al. “ ” 1990, In Proceedings of the 1990 ACM SIGMOD international conference on Management of data - SIGMOD ’90 (Vol. 19, pp. 322–331). New York, USA: ACM Press. DOI :

"Contre-exemples" au théorème de Fermat-Wiles

Fri, 25 Mar 2016 00:00:00 +0000

vient de remporter le pour sa démonstration du qui dit qu’il n’existe pas de solution de l’équation an+bn=cn pour a,b,c,n entiers et n>2. Pourtant :

il a en réalité “seulement” démontré un cas particulier du (aussi appelé conjecture de Shimura-Taniyama-Weil) dont le théorème de Fermat résulte directement
quelques semaines après la publication des quelques 100 pages de la démonstration d’Andrew Wiles en 1995 , Homer Simpson se promène nonchalamment et en 3D devant un contre-exemple : 1782¹² + 1841¹² = 1922¹²

Cette égalité est due à , matheux et co-scénariste de cette . Si on la vérifie sur une calculatrice standard, on trouve que le terme de gauche vaut 2.541210259e+39 et que celui de droite vaut… 2.541210259e+39 ! C’est un contre-exemple du Grand théorème de Fermat, et la démonstration d’Andrew Wiles ne vaut pas tripette!

Mais en fait non:

Avec plus de décimales ou Python, on voit que le terme de gauche vaut 2541210258614589176288669958142428526657 et celui de droite 2541210259314801410819278649643651567616. Ca fait une gigantesque différence de 700212234530608691501223040959, mais comme elle représente moins d’un milliardième des nombres précédents (2.75 10-10 pour être précis), une bête calculatrice du siècle passé qui ne calculait qu’avec 9 chiffres significatifs ou en nombres flottants sur 32 bits pouvait considérer ce chiffre comme comparativement négligeable.
quatre grands problèmes scientifiques résolus sur un seul tableau !

En y regardant de plus près, on voit tout de suite que l’égalité est fausse car comme 1782 est pair, 1782¹² l’est aussi et comme 1841¹² est impair pour les mêmes raisons, la somme 782¹² + 1841¹² est impaire. Or 1922¹² est pair…

Informé de cette dernière objection, David X. Cohen a fait apparaître dans un autre épisode le tableau noir suivant, sur lequel se trouve un autre faux contre-exemple : 3987¹² + 4365¹² = 4472¹². Belle conscience professionnelle, n’est-ce pas ?*

Cette fois l’égalité proposée respecte la parité, et est “moins fausse” que la précédente puisque la différence ne représente que 1.89 10-11 des termes.

Je me suis alors posé trois questions:

y’a-t-il beaucoup de tels contre-exemples ?
y’a-t-il une raison particulière au fait que les deux exemples de David X. Cohen utilisent la puissance 12 ?
peut-on en trouver qui sont encore moins faux que 1.89 10-11 ?

J’ai donc écrit un ** qui génère les triplets (a,b,c) tels que an+bn=cn est juste à 10-9 près, en balayant les nombres a et b entre 100 et 100'000 et incrémentant n à partir de 3. Ce programme s’est révélé productif au point de pouvoir répondre facilement à la question No 1 : oui, il y a des centaines de faux contre-exemples de la qualité de ceux des Simpson pour chaque p et 100 < a,b < 100'000.

Le plus petit faux contre-exemple trouvé donnant une différence inférieure à 10-9 est 1295³ + 216³ = 1297³ . La différence entre les deux termes 2181825071 et 2181825073 n’est que de 2 !

Celui ayant la précision relative la plus élevée est 487674 + 245764 = 495354 L’erreur relative n’est que de 5.1 10-16 soit juste deux fois plus que la précision des nombres flottants sur 64 bits de la plupart des calculatrices actuelles.

A la puissance 5, le record de précision est 843855 + 834525 = 964035 (à 5.67 10-15 près), ensuite la précision des contre-exemples les moins faux diminue lentement quand la puissance augmente. A la puissance 12 il y a 1931112 + 1882112 = 2021812 (1.95 10-12) qui est meilleur que celui de David X. Cohen, qui s’est probablement limité aux nombres de 4 chiffres. Mais je n’ai rien remarqué de particulier pour n=12

Voilà Andrew, comme 99.99% de la population je n’ai rien compris à ta prodigieuse démonstration qui a nécessité 20 ans de vérifications avant que tu reçoive enfin ce prix bien mérité. Je me joins à David et Homer pour te dire juste Bravo !

Notes:

* la dernière ligne du tableau concerne évidemment la topologie (et non, un donut n’est pas isomorphe à une sphère), mais quelqu’un sait-il à quoi correspondent les lignes 1 et 3 ? Je doute que Cohen ait sorti ces équations de nulle part…

** pourquoi Python ? entre autres parce qu’il gère l’ de façon transparente : rien de spécial à faire pour manipuler des nombres énormes.

Références

Andrew Wiles. “Modular elliptic curves and Fermat’s Last Theorem”, 1995, Annals of Mathematics 142 (3): 443–551. . ( )
séquence “Homer³” dans “ ", épisode 6 saison 7, 1995
, Les Simpson épisode 2 saison 10, 1998
video “ ” de Numberphile sur ce sujet (en anglais)

Einsum

Sun, 17 Jan 2016 00:00:00 +0000

Sacré Albert, tu m’as scié encore une fois !

L’autre jour, j’ai rencontré Einstein se promenant incognito dans un bout de code.

J’ai commencé par ne rien comprendre à une ligne de Python trouvée dans un algo de traitement d’image:

norms = np.einsum(‘ij,ij->i’, X, X)

Alors je suis allé voir la doc de la à laquelle je n’ai rien compris non plus, sauf que le bout du nez d’Albert commençait à apparaître via une mystérieuse “ ” qui serait “un raccourci de notation utile pour la manipulation des équations concernant des coordonnées”.

Par exemple, une simple de deux matrices A et B s’écrit

\[mathjax\]

$$A^i{}_j \times B^j{}_k = C^i{}_k$$

avec la notation d’Einstein, et C=np.einsum(‘ij,jk->ik’, A, B) avec la fonction Python correspondante.

On voit que la chaîne de caractères ‘ij,jk->ik’ correspond aux indices des lignes et colonnes des matrices qui figurent en indice et “exposant” dans la notation d’Einstein, dans le même ordre que dans la représentation de la multiplication matricielle ci-dessous:

Pour une simple multiplication matricielle on ne voit pas trop l’avantage sur la notation

$$A \times B = C$$

, mais ajoutons les 3 règles supplémentaires de la notation d’Einstein appliqués à la fonction einsum (traduit de )

Les indices qui se répètent entre (qui peuvent avoir N dimensions) signifient que les valeurs selon ces axes doivent être multipliées. Les produits font les valeurs du tableau de sortie. Dans le cas ci-dessus on a utilisé l’indice ‘j’ une fois pour A et une fois pour B, ce qui signifie qu’on multiplie chaque ligne de A avec chaque colonne de B
Une lettre omise dans le résultat signifie que les valeurs le long de cette axe doivent être sommées. Dans le produit matriciel ci-dessus, ‘j’ ne figure pas dans les indices du tableau de sortie. Cette omission somme le long de cette “troisième direction en réduisant de 1 la dimension du tableau final. Si la signature avait été ‘ij,jk->ijk’, on aurait obtenu une matrice 3x3x3 des produits, et si on n’avait écrit aucun indice mais gardé la flèche ‘ij,jk->’, on aurait obtenu la somme de tous les éléments de C
On peut obtenir les axes non sommés dans n’importe quel ordre. Si on omet la flèche, einsum arrange les indices qui n’apparaissent qu’une fois dans l’ordre alphabétique, donc on aurait pu écrire juste ‘ij,jk’ au lieu de ‘ij,jk->ik’ pour le produit de matrices “normal” ci-dessus. Mais on aurait pu écrire ‘ij,jk->ki’ si on avait souhaité obtenir la du résultat.

Avec ces astuces, beaucoup (toutes?) les opérations vectorielles, matricielles et sur des tableaux à N dimensions peuvent être effectuées par einsum

Signature de einsum	équivalent NumPy	Description
`(A)`	`A`	renvoie le vecteur A
`('i->', A)`	`sum(A)`	somme des valeurs du vecteur A
`('i,i->i', A, B)`	`A * B`	multiplication des vecteurs A et B élément par élément
`('i,i', A, B)`	`inner(A, B)`	de A et B
`('i,j', A, B)`	`outer(A, B)`	de A et B
`('ij', A)`	`A`	renvoie la matrice A
`('ji', A)`	`A.T`	transposée de A
`('ii->i', A)`	`diag(A)`	diagonale de A
`('ii', A)`	`trace(A)`	somme de la diagonale de A
`('ij->', A)`	`sum(A)`	somme des valeurs de A
`('ij->j', A)`	`sum(A, axis=0)`	somme des colonnes de A
`('ij->i', A)`	`sum(A, axis=1)`	somme des lignes de A
`('ij,ij->ij', A, B)`	`A * B`	multiplication des matrices A et B élément par élément
`('ij,ji->ij', A, B)`	`A * B.T`	multiplication des matrices A et B transposée élément par élément
`('ij,jk', A, B)`	`dot(A, B)`	de A et B
`('ij,jk->ij', A, B)`	`inner(A, B)`	produit intérieur de A et B
`('ij,jk->ijk', A, B)`	`A[:, None] * B`	chaque ligne de A multipliée par B
`('ij,kl->ijkl', A, B)`	`A[:, :, None, None] * B`	chaque valeur de A multipliée par B

Les mathématiciens apprécieront l’élégance de la notation, les physiciens pourront manipuler le et d’autres objets mathématiques avec plus de facilité, mais en quoi la fonction einsum est-elle utile aux informaticiens ?

D’abord, elle permet d’effectuer en une seule fois des opérations qui auraient nécessité de stocker des matrices intermédiaires sans ça. De plus le code de la fonction einsum peut être fortement puisqu’il effectue essentiellement des produits puis des sommes sur des vecteurs. Ce n’est en définitive que l’indexation des tableaux qui change en fonction de l’opération désirée, et le tout peut être optimisé dans certains cas en jouant avec la et la commutativité des opérations. Grâce à ceci, la plupart des opérations listées dans le tableau ci-dessus sont entre 1 et 4 fois plus rapides avec einsum qu’avec leur équivalent Numpy, jamais plus lentes. Et pour des opérations plus complexes comme le calcul de la , l’accélération peut être d’un facteur 10 ou plus .

Si vous n’avez pas tout suivi, retenez juste ceci:

Einstein n’était du tout. Il était un surdoué en maths qui a préféré faire de la physique, mais le fait que sa “convention de sommation” apparaisse dans les langages de programmation un siècle plus tard confirme le génie du bonhomme
Que Python est LE langage de programmation scientifique qui s’impose. Oubliez Matlab, qui n’offre même pas de fonction einsum …

Références

Åhlander, K. (2002). “Einstein summation for multidimensional arrays”, Computers and Mathematics with Applications, 44, 1007–1017. \[[pdf](http://www.nik.no/2000/Krister.Aahlander.pdf)\]
Alex Riley, “ ”
sur MathWorld
sur GitHub
(pas simple…)

Comment dire 33 avec 3 cubes ?

Wed, 20 Jun 2012 00:00:00 +0000

Le gars qui m’a pourri ma dernière soirée du printemps s’appelle Mike Croucher. il a négligemment posé le problème suivant:

Il est possible d’écrire beaucoup d’entiers comme la somme des cubes de 3 entiers, par exemple: 99 = (-5)^{3 + 2}3+ 6^3 Un exemple plus compliqué est: 91 = (-67134)^{3 + (-65453)^{3+(83538)^{3 Votre tâche est de trouver les entiers x,y, et z tels que: 33 = x}3 + y}3 + z}3

Comme j’ai bien vu que la solution pour 91 impliquait de grands entiers, je me suis dit que 33 demanderait probablement des nombres encore plus grands, mais j’ai quand même vite pondu le programme Python suivant pour voir:

\[sourcecode lang="Python"\]

res={} #dictionary of results def store(n,x,y,z): if n>=0 and n<100 and n not in res: res

\[n\]

=(x,y,z) print n,res

\[n\]

cube=[] x=0 while True: x3=x*x*x cube.append(x3) for y in range(x+1): y3=cube

\[y\]

for z in range(x+1): z3=cube

\[z\]

store(x3+y3+z3,x,y,z) store(x3-y3+z3,x,-y,z) store(x3+y3-z3,x,y,-z) store(x3-y3-z3,x,-y,-z) store(-x3+y3+z3,-x,y,z) store(-x3-y3+z3,-x,-y,z) store(-x3+y3-z3,-x,y,-z) # store(-x3-y3-z3,-x,-y,-z) #you’re right Neamar, it’s useless x+=1 if x==50: #show “small” results for n in range(100): if n in res: print n,res

\[n\]

else: print n,’?’

\[/sourcecode\]

En moins d’une seconde il trouve les 69 des 100 premiers entiers qui sont des sommes de cubes d’entiers inférieurs à 100. Le plus “compliqué” est 78=-55³+53³+26³ .

Ensuite il mouline pendant des heures pour trouver 51=-796³+659³+602³ et 16=1626³-1609³-511³, et pendant ce temps j’ai exploré les liens émaillant les premiers commentaires .

Il s’avère que le problème soumis par Mike Croucher est extrêmement difficile, voire impossible. liste les solutions trouvées par mon programme, et d’autres qui ont nécessité des algorithmes beaucoup plus fûtés que le mien pour résoudre cette :

87 = 4271³ - 4126³ - 1972³ , découvert en 1964
96 = -15250³ + 13139³ + 10853³
91 = 83538³ - 67134³ - 65453³
80 = -112969³ + 103532³ + 69241³
39 = -159380³ + 134476³ + 117367³ découvert en 1991
75 = - 435203231³ + 435203083³ + 4381159³ découvert en 1993
84 = 41639611³ - 41531726³ - 8241191³ découvert en 1994
30 = 2220422932³ - 2218888517³ - 283059965³ ainsi que 52 = -61922712865³ + 60702901317³ + 60702901317³ par la même équipe, qui a mis au point l’algo le plus performant du moment
24 =15584139827³ - 15550555555³ - 2901096694³ a été découvert avec l’algo précédent en 2001 par D. J. Bernstein, dont la page est consacrée à ce problème et son historique

A part ça, les matheux démontrent (essayez…) que les nombres de la forme 9n+4 et 9n+5 ne peuvent pas être la somme de trois cubes, ce qui règle le cas de 4,5,13,14,22,23 etc.

Bon… je n ai pas vraiment le droit d’utiliser ce dessin, mais il va tellement bien là que j espère que vous ne m en voudrez pas, cher Docteur G…

Reste 33 (et 42 et beaucoup d’autres), qui résistent effrontément aux informaticiens cherchant à les obtenir, ainsi qu’aux mathématiciens essayant de prouver que c’est peine perdue…

C’est énervant qu’un petit problème tout bête comme celui-ci puisse résister ainsi aux ordinateurs les plus puissants. Et motivant de penser qu’une solution est peut-être à la portée d’amateurs éclairés. Des idées ?

Références:

Gardiner, V. L., Lazarus, R. B., & Stein, P. R. “ . “, 1964, Mathematics of Computation, 18, 408-413
Heath-Brown, D. R., Lioen, W. M., & te Riele, H. J. J." ”, 1993, Mathematics of Computation, 61, 235-244
Andrew Bremner, “ ”, 1993
B. Conn and L. Vaserstein, “On sums of three integral cubes”, 1994, Contemp. Math. 166, 285-294.
Eric Pine, Kim Yarbrough, Wayne Tarrant and Michael Beck, Noam D. Elkies, “ ”, 2000, ANTS IV
Michael Beck, Eric Pine, Wayne Tarrant, Kim Yarbrough Jensen “New integer representations as the sum of three cubes”, 2007, Math. Comp. 76, 1683-1690 ( )
Wacław Sierpiński (1988). Elementary theory of numbers. North-Holland. ( )

"jeu de l'année" 2012 et autres : c'est fini.

Wed, 18 Jan 2012 00:00:00 +0000

(mis à jour plusieurs foirs après correction de bugs et améliorations, cf commentaires…)

Je m’apprêtais à passer une soirée tranquille quand je suis tombé sur un tweet de disant: “Qui va me battre au “jeu de l’année” ? ”.

Python bouffant du matheux

Un seul click m’a torpillé non pas une, mais trois soirées et un certain nombre d’heures de réflexion la journée. Mais ma vengeance est terrible : ni ElJj ni aucun autre mathématicien ne passera plus jamais des heures à former les entiers de 1 à 100 en n’utilisant que les chiffres de l’année (2,0,1,2) une et une seule fois chacun, les opérations de base +,-,*,/,^ et quelques autres. Fi-ni. Et c’est rapé aussi pour toutes les années futures ou passées, parce que j’ai fait un programme qui résout ce problème une fois pour toute. Amis , je vous fais ci-dessous économiser des milliers d’heures que vous allez pouvoir utiliser pour résoudre de (Pensez à moi si vous en résolvez un, merci…)

Pour être honnête, la première soirée a été grillée à péniblement trouver 50 formules, ce qui m’a à la fois décidé à faire autrement et inspiré beaucoup de respect pour ElJj et les autres fous qui sont parvenus à obtenir des scores de 4000 et quelques points à la main. Bravo !

Pour 2012, mes solutions sont donc :

\[1, '(((2\*0)-1)^2)', 0\] \[2, '(((2-0)-1)\*2)', 0\] \[3, '(((2-0)-1)+2)', 0\] \[4, '(((2-0)^1)^2)', 0\] \[5, '(((2-0)+1)+2)', 0\] \[6, '(((2-0)+1)\*2)', 0\] \[7, '((2^0)+((1+2)!))', 0\] \[8, '(2^(0+(1+2)))', 0\] \[9, '(((2-0)+1)^2)', 0\] \[10, '((((2+0!)!)-1)\*2)', 0\] \[11, '(((2+0!)!)+(1/.2))', 1\] \[12, '((((2-0)+1)!)\*2)', 0\] \[13, '(2+sqrt((0!+((1/.2)!))))', 1\] \[14, '((((2+0!)!)+1)\*2)', 0\] \[15, '(((2-0)+1)/.2)', 1\] \[16, '(((2+0!)+1)^2)', 0\] \[17, '(((((2+0!)!)-1)!!)+2)', 5\] \[18, '(((2+0!)!)\*(1+2))', 0\] \[19, '((2^0)+(((1+2)!)!!!))', 5\] \[20, '(((2^0)/.1)\*2)', 1\] \[21, '(((((2+0!)!)!!!)+1)+2)', 5\] \[22, '((((2+0!)+1)!)-2)', 0\] \[23, '((.2^(-(0!+1)))-2)', 1\] \[24.0, '((((2-0)^1)^2)!)', 0\] \[25, '((((2+0!)!)-1)^2)', 0\] \[26, '((((2+0!)+1)!)+2)', 0\] \[27, '((2+0!)^(1+2))', 0\] \[28, '(((2+0!)/.1)-2)', 1\] \[29, '(((2+0!)/\[.1\])+2)’, 30] \[30, '((((2-0)+1)!)/.2)', 1\] \[31, '(((2+0!)/.1)+(Gamma(2)))', 31\] \[32, '(2^(-(0!-((1+2)!))))', 0\] \[33, '((((2+0!)!)!!)-((1/.2)!!))', 11\] \[34, '(sqrt((2^(0!/.1)))+2)', 1\] \[35, '((((2+0!)!)+1)/.2)', 1\] \[36, '((((2-0)+1)!)^2)', 0\] \[37, '(0!+(((1+2)!)^2))', 50\] \[38, '(((((2+0!)!)!!!)+1)\*2)', 5\] \[39, '(((.2^(-0!))!)-(\[.1\]^(-2)))’, 31] \[40, '(((2-0)/.1)\*2)', 1\] \[41, '(0!+(2/(.1/2)))', 51\] \[42, '((((2+0!)!)!!)-((1+2)!))', 5\] \[43, '((((2+0!)!)!!)-(1/.2))', 6\] \[44, '(-((.2-(0!/\[.1\]))/.2))’, 32] \[45, '(((((2+0!)!)!!)-1)-2)', 5\] \[46, '(((((2-0)+1)!)!!)-2)', 5\] \[47, '(((((2+0!)!)!!)+1)-2)', 5\] \[48, '((((2+0!)+1)!)\*2)', 0\] \[49, '((((2+0!)!)+1)^2)', 0\] \[50, '((.2^(-(0!+1)))\*2)', 1\]

\[51, '((.2+(0!/.1))/.2)', 3\] \[52, '(2+(0!/(.1\*.2)))', 2\] \[53, '((((2+0!)!)!!)+(1/.2))', 6\] \[54, '((((2+0!)!)!!!)\*(1+2))', 5\] \[55, '(sqrt((((.2^(-0!))!)+1))/.2)', 2\] \[56, '(((((2+0!)!)+1)!!!)\*2)', 5\] \[57, '((((2+0!)!)!!)+sqrt((\[.1\]^{(-2))))’, 35] \[58, '((((2+0!)!)/.1)-2)', 1\] \[59, '((((2+0!)!)/.1)-(Gamma(2)))', 31\] \[60, '(((((2+0!)!)-1)!)/2)', 0\] \[61, '((((2+0!)!)/.1)+(Gamma(2)))', 31\] \[62, '((((2+0!)!)/.1)+2)', 1\] \[63, '((((2+0!)!)!!)+((1/.2)!!))', 11\] \[64, '(2^((0+(1+2))!))', 0\] \[65, '(0!+(2^((1+2)!)))', 50\] \[66, '((((2+0!)!)!!)+(((1+2)!)!!!))', 10\] \[67, '((((.2^(-0!))!!)-\[.1\])/\[.2\])’, 66] \[68, '(20+(((1+2)!)!!))', 15\] \[69, '((((0!+2)!)!!)+21)', 65\] \[70, '(((((2+0!)!)!)\*.1)-2)', 1\] \[71, 'sqrt((((((2+0!)!)+1)!)+(Gamma(2))))', 30\] \[72, 'sqrt((((((2+0!)!)!)\*.1)^2))', 1\] \[73, '(((((2+0!)!)!)\*.1)+(Gamma(2)))', 31\] \[74, '(((((2+0!)!)!)\*.1)+2)', 1\] \[75, '(((((2+0!)!)-1)!!)/.2)', 6\] \[76, '(-((.2^(-0!))-(\[.1\]}(-2))))’, 31] \[77, '((((2^2)!!)!!!)-sqrt((0!/\[.1\])))’, 90] \[78, '((((-2)+(0!/.1))!!!)-2)', 6\] \[79, '(-(2-(0!/(\[.1\]^{2))))’, 30] \[80, '(-((.2-0!)/(.1^2)))', 2\] \[81, '((((.2^(-0!))!!!)-1)^2)', 6\] \[82, '(2+(((0!/.1)-2)!!!))', 6\] \[83, '(2+(0!/(\[.1\]^{2)))’, 30] \[84, '((((.2^(-0!))!!!)!!!)\*(.1+.2))', 13\] \[85, '(((((2+0!)!)!!!)-1)/.2)', 6\] \[86, '((.2^(-0!))+(\[.1\]}(-2)))’, 31] \[87, '(((2+0!)!)+(\[.1\]}(-2)))’, 30] \[88, '(-((((2+0!)!)!)\*(.1-\[.2\])))’, 31] \[89, '(-((.2-((sqrt((0!/\[.1\]))!)!!!))/.2))’, 37] \[90, '(((((2-0)+1)!)!!!)/.2)', 6\] \[91, '(((.2^(-0!))!!!)+(\[.1\]^(-2)))’, 36] \[92, '(2\*(((sqrt((0!/\[.1\]))!)!!)-2))’, 35] \[93, '93', 500\] \[94, '(-(((2+0!)!)-(.1^(-2))))', 1\] \[95, '(-((.2^(-0!))-(.1^(-2))))', 2\] \[96, '(-((.2-0!)\*((1/.2)!)))', 2\] \[97, '(-(2+(0!-(.1^(-2)))))', 1\] \[98, '(-(2-(0!/(.1^2))))', 1\] \[99, '(-((2^0)-(.1^(-2))))', 1\] \[100, '(((2^0)/.1)^2)', 1\]

C’est un peu “brut de décoffrage” et mérite quelques explications. Chaque triplet comporte le nombre à obtenir, la “meilleure” formule qui le donne, et le coût de cette formule en points calculés selon les règles décrites dans l’article d’El Jj. Les formules qui utilisent les chiffres 2,0,1,2 dans l’ordre et les opérations arithmétiques de base et la factorielle (saviez-vous que 0!=1 ?) ont le coût minimum de 0. L’utilisation du point décimal bien utile avec une division ne coute qu’un point. Les formules qui utilisent des opérateurs plus compliqués comme les (notées !! et !!!) et la sont pénalisées de 5 points.

La formule pour 77 est la plus coûteuse (90 points) car elle utilise les chiffres dans le désordre (50 points), le développements décimal périodique

\[.1\]

= 0.11111111… = 1/9 qui vaut 30 points chacun, plus deux multifactorielles. A noter que l’on a eu besoin d’inverser l’ordre des chiffres que dans 4 cas seulement.

Et enfin, les nombre pour lesquels on ne trouve pas de solution sont pénalisés de 500 points, ce qui n’est le cas pour 93, pour lesquel je suis quasi certain qu’il n’existe pas de solution avec les opérations autorisées. Mais seulement “quasi”, pour des raisons que j’explique plus loin.

Le total des pénalités que j’obtiens est de 1637 points

Enfin, les formules ne sont pas très jolies d’une part à cause d’une “surparenthésation” qui simplifie l’écriture du programme (pas besoin de gérer la ), et d’autre part car le choix de la “meilleure” formule lorsqu’on en trouve plusieurs de score égal se fait par la longueur de la chaîne, sans tenir compte de l’ordre d’insertion ou de la priorité des opérateurs. Donc (((2*0)-1)^2) peut paraître plus compliqué que (((2*0)-1)+2) pour obtenir 1, mais pour une machine, c’est le même prix.

Comme il se fait tard je coupe/colle le programme ci-dessous, je le commenterai plus tard (comme d’hab…)

\[code lang="python" collapse="true"\]

# -*- coding: utf-8 -*- """ Created on Mon Jan 16 17:19:27 2012

@author: Philippe Guglielmetti solves """

import sys

from math import sqrt,pow from scipy import factorial,factorial2,factorialk from itertools import permutations

class f: “““a formula””” def __init__(self, m,p=0,v=None,parenthesis=False): #print m,’=’, self.isdigit=isinstance(m, (int, long)) self.math=str(m) #convert to string in case it’s a digit self.points=p if v is None: v=eval(self.math) self.isint=isinstance(v, (int,long)) if isinstance(v, float): #try to convert to int self.isint=abs(v-round(v))<1e-9 if self.isint: v=int(round(v)) if isinstance(v, long): #we don’t want bignums, for performance if abs(v)<sys.float_info.max: v=float(v) self.isint=True self.value=v

if parenthesis: self.math=’(’+self.math+’)’ #print self.value

def __cmp__(self,other): if self.value<other.value:return -1 if self.value>other.value:return +1 if self.points<other.points:return -1 if self.points>other.points:return +1 if len(self.math)<len(other.math):return -1 if len(self.math)>len(other.math):return +1 return 0

def __repr__(self): return str(

\[self.value,self.math,self.points\]

);

class results(dict): “““dictionary of formulas indexed by their result. we keep only the simplest entry for each result”””

def __init__(self): dict.__init__(self)

def add(self, f): if f.value in self.keys() and f>self

\[f.value\]

: pass else: self

\[f.value\]

def merge(self,d): for i in d.itervalues(): self.add(i)

def score(self): return sum(map(lambda x: x.points,self.itervalues()))

def notfound(self,p=500): return

\[i for (i,v) in self.iteritems() if v.points>=p\]

def refine(self,recurse=2): “““add combinations of monadic operators””” r=results() for a in self.itervalues(): if recurse0 and a.value<>0: r.add(f(’-’+a.math,a.points,-a.value,True)) if a.isint: if a.value0: r.add(f(a.math+’!’,a.points,1)) # 0! == 1 is very useful… if a.value>1: s=f(‘sqrt(’+a.math+")",a.points,sqrt(a.value)) if s.isint: r.add(s) if a.value>1 and a.value<19: r.add(f(a.math+’!’,a.points,factorial(int(a.value),True),True)) r.add(f(‘Gamma(’+a.math+’)’,a.points+30,factorial(int(a.value)-1,True),True)) if a.value>3 and a.value<29: r.add(f(a.math+’!!’,a.points+5,factorial2(int(a.value),True),True)) if a.value>4 and a.value<39: r.add(f(a.math+’!!!’,a.points+5,factorialk(int(a.value),3,True),True)) self.merge(r) if recurse>0: self.refine(recurse-1)

class monadic(results): “““combinations of monadic operators around a formula”””

def __init__(self, a): results.__init__(self) self.add(a) if a.value!=0: if a.isdigit: self.add(f(’.’+a.math,a.points+1)) if a.value<10: self.add(f(’

\[.'+a.math+'\]

’,a.points+30,a.value/9.)) self.refine();

class diadic(results): “““combinations of diadic operators of 2 operands”””

def __init__(self, a,b): results.__init__(self) for i in a.itervalues(): for j in b.itervalues(): if i.isdigit and j.isdigit: if i.value!=0: self.add(f(int(i.math+j.math),10)) self.add(f(i.math+’.’+j.math,11)) self.add(f(i.math+’+’+j.math,i.points+j.points,i.value+j.value,True)) self.add(f(i.math+’-’+j.math,i.points+j.points,i.value-j.value,True)) self.add(f(i.math+’*’+j.math,i.points+j.points,i.value*j.value,True)) if j.value!=0: self.add(f(i.math+’/’+j.math,i.points+j.points,float(i.value)/float(j.value),True)) try: #so many things can go wrong with next line… self.add(f(i.math+’^’+j.math,i.points+j.points,pow(i.value,j.value),True)) except: pass if i.isint: try: #so many things can go wrong with next line… self.add(f(‘root(’+i.math+’,’+j.math+’)’,i.points+j.points+5,pow(j.value,1./i.value),True)) except: pass if i.isint and j.isint and i.value>=0 and j.value>0 and i.value/j.value<10: try: #so many things can go wrong with next line… self.add(f(i.math+’!’+j.math,i.points+j.points+5,factorialk(i.value,j.value),True)) except: pass

self.refine();

print ‘building list of monadics’ m=map(monadic,map(f,range(0,10))) #list of all monadics of digits

#use @Memoized here to improve performance def d(a,b): return diadic(a,b)

def year(n,display=True,verbose=True): solution=results() for i in range(1,101): solution.add(f(i,500))

def addresults(a,p): if verbose : print ‘formulas’,len(a), improved=0 found=0 for (i,v) in a.items(): if isinstance(i, (int, long)) and i>0 and i<101: v.points+=p if v<solution

\[i\]

: if solution

\[i\]

.points==500: found+=1 else: improved+=1 solution

\[i\]

=v if verbose: print(‘found :’+str(found)+’ improved :’+str(improved)+’ score:’+str(solution.score()))

def combine (a,p): m0=m

\[a\[0\]

]; m1=m

\[a\[1\]

]; m2=m

\[a\[2\]

]; m3=m

\[a\[3\]

] if solution.notfound():addresults(d(d(d(m0,m1),m2),m3),p) if solution.notfound():addresults(d(d(m0,d(m1,m2)),m3),p) if solution.notfound():addresults(d(m0,d(m1,d(m2,m3))),p) if solution.notfound():addresults(d(m0,d(d(m1,m2),m3)),p) if solution.notfound():addresults(d(d(m0,m1),d(m2,m3)),p)

\[int(i) for i in str(n)\]

combine(y,0) y.sort() for i in permutations(y): combine(i,50)

if display: for i in solution.itervalues():print i print n,solution.score(),solution.notfound()

year(2012)

\[/code\]

les décorateurs, ou pourquoi j'aime toujours la programmation

Sat, 04 Dec 2010 00:00:00 +0000

Je programme des ordinateurs depuis 30 ans, et tous les 5 ans environ je me demande pourquoi je continue à aimer ça. Et à chaque fois je découvre quelque chose qui provoque un “éclair haha”, une de ces illuminations cérébrales où l’on entrevoit le Génie dans toute sa Pureté avant de retomber sur sa chaise motivé pour les 5 ans suivants.

Le dernier a été provoqué cette semaine par les “décorateurs” de Python, dont je vous parlerai plus bas.

Ma première extase informatique date donc de 1980 environ, je m’en souviens comme si c’était hier. Mon 2001 se programmait en BASIC, un langage qu’on a bien fait d’oublier. Mais une astuce (ou plutôt une horreur) sur le PET permettait de faire en sorte que le programme s’ajoute des lignes de programme à lui-même ! J’avais ainsi modifié le jeu “ ” de pour qu’il “apprenne” de nouveaux animaux de façon permanente. Un programme qui s’améliore lui-même, ça me fait encore rêver, 30 ans après…

Le second flash date de 1985, la grande époque de . Un jour j’ai vu quelque chose comme ça:

\[pascal\]

function factorielle(n: integer): integer; begin if n <= 1 then result := 1 else result := n*factorielle(n-1); end;

\[/pascal\]

Une fonction qui s’appelle elle même ! Merveilleuse , chaque fois que je te revois, je me rappelle mon émoi à notre première rencontre.

Les années 1990 sont riches en “haha"s plus rapprochés mais moins intenses pendant mes études à l’EPFL : la en LISP, le moteur d’inférence de , la en d’ADA, qui semblait à l’époque bien plus importante que la programmation orientée objet, juste entrevue. Et , précurseur de la programmation parallèle trop tôt disparu.

Un peu avant 1995, je découvre et le flash se produit lorsque je comprends que c’est un véritable langage de programmation complet… sans code ! Ou plus exactement que le langage graphique de LabView permet de programmer directement au niveau sémantique. Adieu “syntax error” ! Quel dommage que vende cette merveille si cher et l’aie blindé de brevets défendus avec vigueur : un des concepts les plus innovants en programmation reste confiné à un cercle d’initiés alors qu’il aurait pu révolutionner l’informatique.

un "programme" LabView avec blocs concurrents, boucles, tests etc.

Vers 2000, je constate qu’on m’avait menti : C++ est beaucoup plus qu’un C amélioré. C’est un grand festival de “haha” en quelques jours : les , la , l’ , la , les , le , mais surtout la (STL). Java et .NET ont des librairies de classes et fonctions à tout faire, mais C++ a une “méta-librairie”, un système qui produit du code très optimisé pour chaque opération spécifique, en utilisant notamment le concept d’ .

En 2005, je lis Andrei Alexandrescu (2001). Modern C [plus plus] design: generic programming and design patterns applied. Addison-Wesley. . Flash d’illumination : c’est génial, mais j’ai pas tout compris. Je le relis: re-flash: c’est encore plus génial que je pensais. Je le lis une troisième fois (à part “Les Robots” d’Asimov je n’ai jamais lu un livre 3 fois) : ça y’est je suis converti au “ ”, une approche révolutionnaire de la programmation autorisée par une exploitation transcendantale de la combinaison C++, STL, et #macros. Les C++istes trouveront un petit qui les convaincra à la fois de la puissance de cette approche, et de sa lourdeur d’écriture…

Et nous voici donc en 2010 où, poursuivant , je tombe sur ça:

\[python\]

@cache() def fib(n): if n < 2: return 1 return fib(n-1) + fib(n-2)

\[/python\]

Même ceux qui ne parlent pas Python reconnaîtront une fonction récursive calculant le n-ième terme de la suite de Fibonacci, mais il y a une astuce : le @cache().

Ca s’appelle un “décorateur” et en l’occurrence, le @cache() ajoute un comportement de (déjà mentionné ) à la fonction : si on appelle la fonction fib pour un n déjà calculé précédemment, le @cache() va renvoyer le résultat mémorisé avec un gain de vitesse appréciable plutôt que de recalculer la fonction, et ceci sans rien changer à la fonction elle-même!

Et bien sur, le décorateur est lui-même écrit en Python : c’est , et c’est une version simplifiée d’un avec la librairie Python. Une très variés est en train de naître (voyez par exemple les , chers collègues…), mais il me semble que les décorateurs permettent surtout de réaliser des choses ressemblant beaucoup aux “politiques” d’Alexandrescu avec une syntaxe plus simple qu’en C++. (Pythonistes, voyez )

C’est pour cela que j’aime toujours la programmation : les langages gagnent en pouvoir d’abstraction en même temps que moi, et vice-versa. Chaque fois que je programme dans un nouveau langage, tout est plus simple, plus clair et plus vite juste que dans le précédent, et, luxe suprême, je dois presser moins de touches. Les ordinateurs sont restés des esclaves qui camouflent leur stupidité derrière une vitesse stupéfiante, mais les concepteurs de langages, eux sont devenus vraiment malins. Merci , grâce à toi j’en reprends pour 5 ans.

Démosaïquification

Wed, 03 Dec 2008 00:00:00 +0000

C’est très facile de faire une comme celle ci-contre. Des sites comme en quelques secondes des centaines d’images pour approximer une image de base.

Par exemple, voici un détail du goulot du bécher ci-contre:

Mais combien de petites images distinctes sont utilisées pour produire la mosaïque ? Pour répondre à cette question, j’ai développé un petit programme avec en utilisant la

Le programme produit un , avec à côté toutes les copies de cette image identifiées par le programme.

Le programme Python est ci-dessous, il est relativement simple, à l’exception de la fonction permettant de comparer les images pour laquelle j’ai pas mal ramé, et il reste un seuil numérique à ajuster au cas par cas, mais dans l’ensemble ça marche…

A quoi ça sert tout ça ? Outre à tester le traitement d’image en Python avec PIL, c’est pour gagner un concours, mais je ne vous dirai pas (encore) lequel

\[code lang="python"\]

import Image; #PIL import ImageChops; import ImageStat; import math;

im = Image.open(“mosaic.jpg”) smallx=40; smally=40;

border=1; #ignore border of picture print im.size

\[0\]

,im.size

\[1\]

n=(im.size

\[0\]

/smallx)*(im.size

\[0\]

/smally) nx=math.sqrt(n)

res=Image.new(im.mode,(smallx*nx,smally*n)) L=[]; jmax=0; y=0; while y<im.size

\[1\]

: x=0; while x<im.size

\[0\]

: box = (x+border, y+border, x+smallx-border, y+smally-border) mini = im.crop(box) mininb=ImageOps.equalize(mini.convert(‘L’)) min=1000; for i in range(len(L)): rms=ImageStat.Stat( ImageChops.difference( mininb,L

\[i\]\[0\]

) ).mean

\[0\]

if rms<min: f=i; min=rms; if min<30: #this must be tuned for each case … j=L

\[f\]\[1\]

=j+1 else: j=0 f=len(L) L.append(

\[mininb,1\]

) if j>jmax: jmax=j; box = (smallx*j+border, smally*f+border) res.paste(mini,box); x=x+smallx print ‘.’, y=y+smally

res.crop((0,0,(jmax+1)*smallx,len(L)*smally)).save(‘result.jpg’) print ‘DONE!’ print len(L),‘different images over’,n,‘max’,jmax+1,‘copies’

res.crop((0,0,(jmax+1)*smallx,len(L)*smally)).save(‘result.jpg’) print len(L),‘different images over’,n,‘max’,jmax+1,‘copies’

\[/code\]

Python(x,y)

Fri, 17 Oct 2008 00:00:00 +0000

est un langage très puissant, mais livré dans un état un peu brut. Pour l’exploiter de façon efficace, il faut y ajouter des libraires graphiques, de calcul spécialisé ou d’accès à des bases de données par exemple. Certaines ne sont que des interfaces vers des librairies en C ou C++, ce qui implique souvent des étapes d’installation, voire de compilation. De plus on se heurte souvent à des conflits de version entre les librairies et Python lui-même, ce qui ne simplifie pas les choses. Enfin et surtout, un bon IDE (Environnement de Développement Intégré, à l’envers en anglais…) est indispensable pour programmer au XXIème siècle.

résout tout ces problèmes en proposant un installeur unique de la Parfaite Panoplie du Petit Programmeur Scientifique. Elle inclut:

, évidemment (version 2.5.2 actuellement)
, le meilleur IDE de la Galaxie. Concu initialement pour Java, Eclipse permet de développer dans pratiquement tous les langages connus à l’aide de plugins. est celui qui supporte Python.
, le “Minimalist GNU for Windows” qui comprend le célèbre compilateur C++ “GCC”. Grâce au plugin Eclipse également fourni, Python(x,y) est donc en même temps un environnement de développement C++ très complet
pour exploiter , le framework d’applications multiplateforme de Nokia. Intégré à Eclipse, l’ensemble permet de créer des GUI (Interfaces Utilisateur Graphiques, à l’envers en anglais)
une myriade de librairies scientifiques pour le traitement du signal et d’images, le calcul symbolique, la visualisation graphique 2D et 3D, le calcul parallèle etc. La liste complète est et le tout est résumé dans ce beau “mind map” :

Un avantage non négligeable de Python(x,y) est qu’elle est une oeuvre de Pierre Raybaut. Je ne le connais pas, mais c’est un français, donc toute la documentation et le support de la distribution sont dans la langue de Molière.

Que vous vouliez vous initier à Python, simplement utiliser des libriaires qui vous donneront accès à un équivalent de Matlab ou vous lancer dans le développement d’une grosse application Python, je ne peux que vous recommander chaudement d’installer Python(x,y)

Python : un petit Sudoku pour commencer

Sun, 12 Oct 2008 00:00:00 +0000

Ces temps-ci, je découvre , un langage de programmation très apprécié en particulier dans la communauté scientifique. Ce “ ” intègre des concepts développés dans plusieurs langages récents, ce qui en fait peut-être le langage le plus complet disponible actuellement.

Pour une première approche de ce langage, je vous propose l’analyse du…

Plus Court Solveur de Sudoku

Voici un programme en Python de 173 caractères seulement qui serait le plus court connu actuellement :

\[sourcecode lang="python"\]

def r(a): i=a.find(‘0’) if i<0:print a

\[m in\[(i-j)%9\*(i/9^j/9)\*(i/27^j/27|i%9/3^j%9/3)or a\[j\]

for j in range(81)]or r(a

\[:i\]

+m+a

\[i+1:\]

)for m in`14**7*9`]r(raw_input())

\[/sourcecode\]

Ce programme est extrêmement compact et condensé, voire cryptique à l’instar des . Ce n’est pas forcément la meilleure façon de programmer, mais ça révèle souvent la puissance cachée de certains langages. Ce programme est décrit en anglais et en détail , mais voici son principe en gros et en français:

def r(a): ... r(raw_input()) // définit la fonction “r” qui résout le sudoku, puis on l’appelle en passant en paramètre ce que l’utilisateur a entré au clavier. Ca doit être une chaine de 81 caractères contenant ligne par ligne les chiffres de 1 à 9 donnés, et des 0 aux emplacements vides.

i=a.find('0') if i<0:print a // au début de la fonction, on cherche le premier emplacement vide. Si on ne le trouve pas, on imprime le sudoku résolu

la partie principale de la fonction utilise deux concepts puissants de Python:

la “lazy evaluation” qui fait que l’expression “a or b” est équivalente à “if not(a):b”
la “compréhension de liste” qui permet de créer une liste en écrivant une boucle à l’intérieur de \[crochets\]. Par exemple “l = \[x\*\*2 for x in range(10)\]” crée la liste des carrés des 10 premiers nombres entiers

ainsi cette expression [(i-j)%9*(i/9^j/9)*(i/27^j/27|i%9/3^j%9/3)or a[j]for j in range(81)] fournit la “liste d’exclusion” contenant les chiffres qui ne peuvent pas figurer dans le trou à la position i. On l’obtient en parcourant toutes les celllules et en ajoutant à la liste la valeur des cases a

\[j\]

situées sur la même ligne, la même colonne ou dans le même bloc que i. Le grand test compliqué détermine ces conditions en utilisant les opérateurs modulo (%), ou binaire (|) et ou exclusif (^).

Finalement, le [m in [...] or r(a[:i]+m+a[i+1:])for m in`14**7*9`] remplit successivement la grille avec les chiffres possibles en utilisant la ’lazy evaluation’ une fois de plus : ce n’est que si le chiffre m n’est pas dans la liste d’exclusion qu’on execute la partie droite du or, laquelle appelle récursivement la fonction r en lui passant la grille en paramètre la grille a[:i]+m+a[i+1:]. Ici , l’opérateur + sert à concaténer des listes : d’abord les i-èmes premières cases, puis le chiffre m proposé pour la case vide, puis les cases à partir de la i+1 ème.

Ce programme utilise donc une approche “force brute” loin d’être optimale en temps de calcul : on essaie les chiffres possibles dans chaque case vide jusqu’à ce que ça marche.

Reste à découvrir une astuce de geek que je ne connaissais pas : 14**7*9 vaut 948721536, un nombre qui contient les chiffres 123456789, dans le désordre, mais ça va aussi pour notre application. Les backquotes ´…´ servent à former une chaine, comme d’ailleurs la fonction str(). L’avantage de ´14**7*9´sur ´123456789´ ? ben c’est évident : il faut deux bytes de moins …

Palindrome de 196

Sun, 14 Sep 2008 00:00:00 +0000

palindrome par puja (flickr)

Prenons un nombre au hasard : 1729. Ecrivons-le à l’envers : 9271 et additionnons les deux nombres : 1729+9271=11000. Recommençons avec ce nombre : 11000+00011 = 11011.

Ce nombre est égal à lui même écrit à l’envers, c’est un nombre , comme le mot “radar” ou la phrase “élu par cette crapule” si on ne tient pas compte des espaces, ou encore “ ”, un texte de 5566 lettres écrit par Georges Perec en 1969.

Tiens, refaisons le calcul avec 1969 pour voir : 1969+9691 = 11660 11660+06611 = 18271 18271+17281 = 35552 35552+25553 = 61105 61105+50116 = 111221 111221+122111 = 23332 : palindrome !

Bizarre n’est-ce pas ? En fait on peut prendre n’importe quel nombre de départ, et la séquence d’opérations arrive inévitablement à un nombre palindrome en un nombre fini d’itérations. C’est du moins ce que l’on , car il y a deux problèmes :

nos amis mathématiciens n’ont aucune idée de la raison qui fait que ça marche, entre autre parce que “écrire un nombre en base 10 à l’envers” n’a pas de signification mathématique simple.
il y a un gros hic. Si on commence avec 196, on n’arrive pas à un palindrome même après 300 millions d’itérations…

196 est le plus petit des “ ” (en l’honneur de Cheryl, la petite amie du matheux qui a proposé cette propriété) : les nombres qui n’aboutissent apparemment pas à un palindrome … se trouvent évidemment , mais aussi quelques autres.

Ce qui est intéressant aussi, c’est la distribution du nombre d’itérations : très souvent, on atteint le palindrome en quelques étapes, même pour de très grands nombres, mais quelques rares nombres demandent quelques étapes de plus

Par exemple pour les nombres de 1 à 99, on arrive à un palindrome en 4 itérations ou moins pour 98 nombres, 79 et 97 ont besoin de 6 itérations, mais 89 et 98 nécessitent 24 itérations.

Pour les nombres de 1 à 999, 929 atteignent le palindrome en 6 itérations ou moins, 13 sont des nombres de Lychrel et les 57 restant ont besoin de moins de 24 étapes : 89 et 98 sont toujours les plus gourmands en itérations

Poussons jusqu’à 10'000 : à part les 249 (edit du 6.1.14 : et non 246) nombres de Lychrel, il n’y a toujours pas d’autre nombre que 89 et 98 qui nécessite plus de 24 itérations.

La quête du “ ” a commencé par ces résultats :

Nombre	Iterations	Palindrome
10911 147996 150296 1000689 1005744 1017501 7008899 9008299	55 58 64 78 79 80 82 96	4668731596684224866951378664 8834453324841674761484233544388 682049569465550121055564965940286 796589884324966945646549669423488985697 796589884324966945646549669423488985697 14674443960143265333356234106934447641 68586378655656964999946965655687368586 555458774083726674580862268085476627380477854555

le record du monde actuel (2008) date de 2005 et concerne le nombre 1'186'060'307'891'929'990, qui produit un palindrome de 119 chiffres après 162 itérations.

On voit que le nombre maximal d’itérations requises n’augmente que très lentement, ce qui rend les nombres de Lychrel encore plus intriguants et exceptionnels.

A propos : j’ai commencé cet article par est peu intéressant : 1548+8451 = 9999. Ou alors, 30 ans plus tard, je viens de découvrir une nouvelle propriété de ce nombre …

Références:

pour le calcul de palindromes
sur MathWorld