Programmation | Dr. Goulu

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 :

La première boucle

Sun, 26 Jun 2016 00:00:00 +0000

Comme d’autres sources fort sérieuses, Sirtin a récemment fait remonter l’origine de l’informatique aux métiers à tisser Jacquard, “programmables” par cartes perforées au tout début du XIXème siècle déjà . Pour ma part je n’adhère pas à cette filiation car les métiers Jacquard ne connaissaient pas la notion de : si on voulait qu’ils tissent 123 fois un motif, il fallait répéter 123 fois la même séquence de petits trous sur les cartes perforées. Autrement dit ces cartes perforées ne contenaient pas un programme mais des données pour un lecteur qui ne faisait que commander des éléments mécaniques indépendants.

Une idée fondatrice de la programmation, c’est de pouvoir coder “répète 123 fois ceci:”, et que la machine ait un moyen de compter jusqu’à 123, ce qui implique l’existence d’une mémoire dont le contenu est modifié par les instructions du programme. Comme l’a très bien exprimé Alan Perlis dans un de ses :

Un programme sans boucle et sans structure de données ne vaut pas la peine d’être écrit.

Ada, en tenue de geek de 1836

Alors qui a écrit le premier programme valant la peine d’être écrit, la première boucle ? C’est . Parfaitement : une femme . Et ceci bien avant qu’ ne propose sa , dont l’intérêt est surtout théorique.

Au contraire, Ada Lovelace a travaillé avec sur un problème bien pratique : établir des tables nautiques, astronomiques et mathématiques exactes en automatisant leur calcul, car à l’époque ces tables calculées à la main étaient truffées d’erreurs. Des comme la ou la “multiplicatrice” de facilitaient déjà le travail, mais Babbage voulut construire une “ ” capable de produire des tables en évaluant des polynômes de manière itérative. Tout en la construisant, il se lança dans la conception d’une “ ” réellement programmable, et dotée notamment d’une mémoire et d’un mécanisme de qui permettait l’exécution de boucles. Un hardware au sens propre : tout en rouages et cames propulsées à la vapeur…

Et c’est Ada Lovelace qui s’est attaquée au “software”. Imaginez que vous soyez à sa place et que vous disposiez de la première et unique calculatrice programmable de l’histoire, qui coûte des millions de livres de l’époque et dont la fiabilité précaire rend chaque opération précieuse. Que proposez-vous comme programme qui “vaut la peine d’être écrit” ? Certainement pas for i=1 to 100:print i; ni les nombres de Fibonacci ou les nombres premiers qu’on connait déjà. Ce qu’Ada a choisi pour le premier programme de l’histoire, c’est de calculer les dont je vous ai . Pourquoi ? Parce qu’avec eux et la on peut calculer plein de tables et d’intégrales utiles.

Lady Ada a donc écrit le premier programme utile de l’histoire, que voici , :

Les boucles sont indiquées par les accolades dans les premières colonnes et par le texte “here follows a repetition of Operations thirteen to twenty-three”. La fameuse “Note G” rédigée par Ada Lovelace au base de montre clairement qu’elle a inventé les notions de variables et de boucle en programmation:

It will be perceived that every unit added to n in B2_n_-1, entails an additional repetition of operations (13…23) for the computation of B2_n_-1. Not only are all the operations precisely the same however for every such repetition, but they require to be respectively supplied with numbers from the very_same pairs of columns_; with only the one exception of Operation 21, which will of course need B5 (from V23) instead of B3 (from V22). This identity in the columns which supply the requisite numbers must not be confounded with identity in the values those columns have upon them and give out to the mill. Most of those values undergo alterations during a performance of the operations (13…23), and consequently the columns present a new set of values for the next performance of (13…23) to work on

fonction de calcul des nombres de Bernoulli en Javascript langage ADA, par S. Goodwin [4)

Et accessoirement que Madame Lovelace commentait son code en prose intelligible, une habitude qui se perd. Exemple : le code ci-contre qui calcule les nombres de Bernoulli en et hélas pas en , baptisé ainsi en l’honneur de la première véritable programmeuse de l’histoire.

Mais on l’a longtemps oubliée car son code n’a hélas jamais pu être exécuté : la machine analytique de Babbage avait trop de frottements, trop d’imprécisions mécaniques, elle n’a jamais fonctionné…

Le premier calculateur réellement programmable ayant fonctionné est, n’en déplaise aux cow-boys, allemand. Le de a été construit en 1941 et détruit lors d’un bombardement en 1943, mais entre deux il a été utilisé pour calculer des choses et donné naissance au premier “vrai” langage de programmation de l’histoire : . Cependant, le Z3 ne permettait pas le qui semble aujourd’hui indispensable à toute boucle utile. Mais comme expliqué dans et , le Z3 était bel et bien grâce à deux horribles magouilles:

on pouvait assigner le résultat binaire d’un test à une variable, par exemple if i>123 then t=0 else t=1; puis utiliser cette variable pour coder les deux “branches” correspondant au “then” et au “else” en codant des formules comme a=t*x+(1-t)*y; qui fait a=x ou a=y selon la valeur de t
on pouvait effectuer une boucle infinie en scotchant la fin de la bande perforée au début pour qu’elle tourne en rond, et rendre la boucle finie avec un code du genre a=a/t qui ne faisait rien tant que t=1, et provoquait une erreur “division par zéro” quand t=0, ce qui arrêtait la machine. Beark! Mais efficace.

C’est sans aucun doute Konrad Zuse qui a fait tourner la première boucle conditionnelle de l’histoire, mais hélas on ne sait plus quel était le premier programme à utiliser cette possibilité.

page de programme ENIAC par Klara von Neumann

Comme ce sont les vainqueurs qui écrivent l’histoire, je termine en mentionnant tout de même l’ , qui fut la première machine Turing-complète électronique. Conçue par selon l’architecture qui est toujours celle des ordinateurs actuels. Cette machine est la première a être programmable au sens moderne du terme avec mémoire, branchements conditionnels, boucles, et femmes.

En effet, avant chaque calcul, les différentes unités de l’ENIAC doivent être reconfigurées par câblage, une tâche dévolue aux 6 “ ” Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas et Ruth Lichterman. Elles aussi longtemps oubliées par l’histoire, un récent reportage leur rend un hommage mérité. J’en ai retenu une phrase :

“The ENIAC was a son of a bitch to program”

On dit souvent que l’ENIAC a servi au calcul de la bombe atomique. Ca dépend laquelle : , Hiroshima et Nagasaki ont eu lieu en 1945, avant qu’ENIAC soit opérationnelle en 1946. Mais ENIAC a effectivement été utilisée pour le développement des armes nucléaires américaines dans les années 1950. Par exemple le petit bout de code ci-contre provient d’un programme de calcul par la des neutrons diffusés lors de la fission nucléaire. Et ce code est du à , la femme de John. Oui, encore une femme.

Qui ose encore prétendre que l’informatique est un truc de mecs ?

Références

“Le tissage à l’origine de l’informatique ?” , et chez Sirtin
Christian Braesch “ ”
Anne-Marie Kermarrec “ ”, 2015, Binaire, Le Monde
Steven Goodwin “
Eugene Eric Kim, Betty Alexandra Toole, “Lady Ada et le premier ordinateur”, 1999, Pour la science No 261,p 64‑69. (
L. F. Menebrea, “ ” Bibliothèque Universelle de Genève, Octobre 1842, No. 82, ( )
Bram Bruines “ ”, 2010
sur StackOverflow
Raul Rojas" ", 1998
sur
Len Shustek “ ”, 2016

"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)

Bits en vrac

Wed, 09 Apr 2014 00:00:00 +0000

Quelques découvertes informatiques en vrac

Les formulaires Google Drive

Le m’a permis d’expérimenter la puissance et la facilité d’utilisation des . C’est simplement génial :

dans , on crée un document de type formulaire
on se retrouve dans un éditeur permettant de composer le formulaire. On peut définir le type de chaque champ : texte, choix multiple, cases à cocher, échelle d’évaluation, tout y est. On peut ajouter des règles de validation et des actions à effectuer en fonction des réponses

Editeur de Formulaire Google Drive
En cliquant le bouton “afficher le formulaire en ligne” on peut voir à quoi ça ressemble pour les utilisateurs et même tester le système, car la collecte des réponses est immédiate : rien à faire de particulier !
Lorsque le formulaire est prêt, il suffit d’envoyer le lien disponible par “Envoyer le formulaire” à des personnes choisies, ou d’intégrer la page sur un site web dans un . Plusieurs blogs du C@fé des sciences l’ont même fait simultanément sans aucun problème car le formulaire n’existe en réalité (virtuelle…) que chez Google.
Les réponses sont automatiquement collectées dans un document “tableur” sur Google Drive : une ligne est créée pour chaque formulaire rempli, chaque colonne correspondant à un champ. Notez la colonne “horodateur” remplie automatiquement, bien utile.

Table des résultats

Ce que j’ai trouvé assez impressionnant est que l’on peut modifier le tableau sans perturber les votes suivants. Apparemment chaque champ du formulaire est attaché à une colonne par un lien invisible, mais solide : même si on ajoute ou déplace des colonnes, les réponses suivantes restent cohérentes avec les réponses précédentes. Pour le quiz, j’ai ajouté la ligne 2 avec les bonnes réponses ainsi que la colonne D Score. Notez au passage la géniale formule qui compte le nombre de réponses correctes avec et sumproduct. Elle n’est pas de moi, et il parait qu’elle est possible aussi en Excel…
résumé des réponses

Une petite dernière pour la route : dans le menu “Formulaire” on peut “afficher le résumé des réponses” qui présente les résultats sous une forme graphique qui peut être bien utile.

Les formulaires Google Drive permettent de réaliser facilement des sondages, quiz et concours divers avec toute la puissance et la sécurité (…) de l’infrastructure Google. Ca fait déjà des dans le C@fé …

Curation V.3.0‎

Rien à faire, il n’y a toujours pas mieux pour suivre les sites intéressants que les . J’ai longtemps utilisé avec lequel j’ai commencé à faire de la . En effet, en cochant simplement les articles que je trouvais intéressants, Google Reader les agrégeait dans un flux RSS “de sortie” que je pouvais publier sur .

Puis Google a annoncé la fermeture de Reader (toujours incompréhensible pour moi) et j’ai utilisé . C’était une bonne idée : Scoop.it permet d’agréger non seulement des flux RSS, mais aussi des tweets, le contenu de pages Facebook et de recherches Google. On peut créer ainsi plusieurs “topics” thématiques, et de jolis widgets comme celui ci-contre à droite. Mais le point fort de Scoop.it, c’est ses possibilités de partage : chaque contenu “scoopé” peut être partagé automatiquement sur Twitter, Facebook, Gogle+ et Tumblr, entre autres.

Scoop.it, c’est vraiment bien, mais … il y a un problème rédhibitoire : les liens du contenu partagé sont modifiés pour conduire les visiteurs sur la page Scoop.it du topic, et pas directement vers l’article original. Ceci a trois conséquences que je trouve gênantes:

La première n’est pas trop grave : les lecteurs doivent cliquer deux fois pour arriver à l’article qui les intéresse, une fois sur la page où ils voient le contenu partagé, puis une seconde fois sur la page Scoop.it.
La seconde fausse les analyses de trafic, qui semble provenir de Scoop.it plutôt que du site de partage. Ainsi par exemple mon site a accueilli plus de 2000 visiteurs passés par Scoop.it en un an sans qu’il me soit possible de déterminer où ces 2000 personnes ont initialement découvert l’article qui les intéressait.
La troisième touche le droit d’auteur : les outils de partage qui changent les liens diffusent le contenu d’autrui en coupant le lien vers la source, qui est parfois le seul élément identifiant l’auteur. Je me suis soudain aperçu que “rebloguait” automatiquement les articles que je trouvais intéressants, parfois en me les attribuant implicitement puisqu’il n’y avait plus de mention du site original.

Je me suis donc mis en chasse de nouveaux outils de curation, et après quelques essais j’ai choisi le “trio de la curation V.3” :

comme agrégateur de flux. Il offre grosso-modo les fonctionnalités de Google Reader, une , plus une (en fait un plugin d’un agrégateur plus général). Chaque jours je parcours une centaine d’articles en sautant d’un à l’autre en pressant la touche \[j\], et si je le trouve intéressant je le lis et je presse \[s\]comme “star”. Ca le marque comme favori et l’ajoute à mon .
Je pourrais utiliser directement CommaFeed pour partager le contenu sur Facebook, Twitter, Google+ et autres (mais pas Tumblr). Mais surtout, il me faudrait le faire manuellement : 6 ou 8 clicks de plus, c’est trop. Alors j’ai utilisé , un service qui permet d’automatiser des tâches internet en créant des “recettes” de la forme If This Then That . J’ai ainsi créé des “recettes” qui partagent automatiquement le contenu de mon flux de sortie vers mes pages Facebook, Google+, App.net et Tumblr. Automatiquement. Rien d’autre à faire :-) (Pour Twitter j’hésite encore…)
Et j’utilise toujours Scoop.it pour atteindre les utilisateurs de cette plateforme et profiter des beaux widgets, mais je n’utilise plus les outils de partage. En attendant qu’IFTTT permette de “scooper” automatiquement, j’utilise le flux de sortie comme unique source dans Scoop.it et je “scoope” à la main tout ce que j’ai préalablement sélectionné dans CommaFeed.

Tout ça ne me demande en définitive pas plus d’efforts que de tourner les pages d’un journal en papier, et je peux me concentrer sur la lecture tout en gardant une trace dont vous pouvez profiter où vous le souhaitez.

NetworkX

est une librairie Python permettant de représenter et traiter des problèmes de graphes. Je l’utilise professionnellement assez intensivement ces temps-ci pour un , mais l’autre jour il m’a permis de résoudre le du en quelques lignes seulement. En fait la plupart servent à lire le fichier des données, puis la partie intéressante tient en une seule ligne :

\[source lang="Python"\]

print G.size(weight=‘weight’) - minimum_spanning_tree(G, weight=‘weight’).size(weight=‘weight’)

\[/source\]

Fort non ? Hélas il me semble que peu de problèmes du Project Euler concernent les graphes, donc je ne vais pas pouvoir améliorer mon score rapidement …

2048

Cet article serait paru il y a trois jours si je n’étais pas tombé sur , le jeu addictif du moment. C’est un jeu tellement simple qu’il aurait du être inventé avant Pac-Man. Et on voit tout de suite comment faire : placer les puissances de 2 les unes à côté des autres pour former une chaîne croissante et propager ainsi les sommes pour arriver à former enfin, après 1024 coups au minimum, la tant convoitée pièce 2048. Il m’a fallu 3 jours. Enfin 3 soirs. 3 nuits…

A un certain moment j’en ai eu marre et voulu utiliser la bonne vieille méthode pour résoudre les problèmes compliqués : programmer. Mais Matt Overlan a été plus rapide et efficace : et est très instructif. Je crois que c’est la première fois de ma vie qu’un ordinateur m’apprend à résoudre un casse-tête plutôt que l’inverse. Peu après avoir observé le solveur parvenir au 2048, j’ai appris à dominer ma tentation d’additionner coûte que coûte les nombres les plus élevés et à conserver des lignes ou des colonnes de 4 cases “bloquées”, et j’ai gagné.

Après certains passent au voire au , mais je crois que je vais plutôt attaquer la version “ ” de Valentine. Un peu déroutant de prime abord, mais j’aime beaucoup l’idée un peu holiste qu’il y a là derrière… Bravo !

La programmation, latin du futur ?

Sat, 07 Sep 2013 00:00:00 +0000

Dans un récent article Anna Lietti fait le point sur une question qui fait son chemin un peu partout:

Pour former des citoyens «informatiquement éclairés»*, l’école doit-elle enseigner à tous le b. a.-ba de la programmation?

Selon certains comme , les enfants du numérique ont une “expérience rusée” du fonctionnement des machines, mais leur approche intuitive approche vite ses limites et ne leur permet pas de dominer la machine. Or cette domination est nécessaire pour contrôler notre monde, de plus en plus automatisé, numérique et interconnecté. On le voit avec l’affaire : contrôler , c’est avoir le pouvoir sur ses utilisateurs…

Des précurseurs comme (élève de ) se sont intéressés dès les années 1960 à la pédagogie de l’informatique et inventé des outils comme le pour initier à l’algorithmique et à la programmation procédurale dès l’enfance. Pourtant, 50 ans plus tard, aucun pays n’intègre la programmation au cursus scolaire primaire, peu le font au niveau secondaire, et la branche y est rarement obligatoire.

En Grande-Bretagne, suite à un rapport de la Royal Society intitulé “Shut down or restart” qui jugeait l’enseignement de l’informatique tellement insatisfaisant qu’il vaudrait mieux ne rien faire, la décision a été prise d’initier les enfants dès 5 ans à la programmation dès la rentrée 2014 et que la programmation devienne une branche obligatoire du baccalauréat au même titre que la physique ou la chimie.

En France aussi, un récent rapport de l’Académie des Sciences vient de recommander d’aller plus loin que la récente (ré)introduction de la spécialité “ ” en terminale S , en incluant “une initiation aux concepts de l’informatique” dès l’école primaire , puis “un véritable enseignement d’informatique, qui ne soit pas noyé dans les autres enseignements scientifiques et techniques, mais développe des coopérations avec ceux-ci dans une volonté d’interdisciplinarité” au collège, puis “proposer un enseignement obligatoire d’informatique en seconde” au lycée.

Plusieurs initiatives se développement également en Suisse, notamment:

le Prof. Juraj Hromkovic avec son module “ ”, adopté dans une trentaine d’établissements en Suisse alémanique
Jürg Kohlas, qui promeut l’enseignement de l’informatique comme discipline fondamentale au gymnase (=lycée) dans un livre tout récent , en recommandant de commencer par former les professeurs, un problème qui semble général…
un "script" en Scratch

Manuela Barraud et Olivier Jorand proposent des ateliers de “ ” combinant programmation et robotique ludique dans la continuation de la “philosphie Logo”, mais ils forment aussi des enseignants à leur approche. Outre Logo, ils utilisent le langage semi graphique développé au MIT pour les enfants dès 7 ans.

Pour ma part, voici les quelques leçons que je tire de ma maigre expérience de l’enseignement de la programmation des deux côtés de la barrière:

Pas facile d’être prof. quand certains élèves maîtrisent mieux le sujet. Il faut une formation en béton, et si possible conserver le choix des armes…
La robotique est très motivante pour les jeunes. Avec juste une boucle et quelques tests on peut faire bouger quelque chose de concret alors que sur un écran il faut beaucoup plus de code pour faire quelque chose d’un tant soit peu excitant.
Mais les robots c’est cher et délicat, alors les environnements virtuels en 3D sont un bon compromis : ils conservent un rapport résultat visuel/code élevé tout en ouvrant des possibilités amusantes comme sans que la SPA ne proteste ( ), ou monter un canon sur un robot sans occasionner trop de dégâts ( testé avec succès au )
L’âge minimum pour s’intéresser à la programmation est celui où l’enfant est capable de comprendre la notion de . Je dirais expérimentalement vers 10 ans. Les boucles, les tests, même les sous-programmes et les fonctions peuvent encore passer plus tôt avec des choses comme “POUR CARRE : REPETE 4 \[AV 100 TD 90\]: FIN”, mais c’est peut-être justement une raison de l’échec de la programmation au primaire : sans la capacité d’abstraction nécessaire pour associer une information (nombre, texte etc…) à un symbole, on est très vite limité. Or cette n’est introduite, sauf erreur, que vers 10-12 ans, et n’est pas assimilée facilement par tous. Imaginez alors la pagaille dans les esprits si le prof de maths dit que “x=2*x-1 a pour solution x=1” et l’heure d’après celui d’informatique dit que “x=x+1 incrémente la valeur de x” …
Il est très difficile de découpler l’enseignement de la programmation de celui des maths. En particulier pour la robotique ludique (réelle ou virtuelle) on a très rapidement besoin des vecteurs, de la trigonométrie, voire de notions d’intégration et dérivation pour passer des vitesses aux positions ou vice-versa.

Donc je ne crois pas à l’introduction de la programmation au primaire. Et sans programmation, pour quoi “faire de l’informatique” ? Et plus tard, au collège et au lycée, à quoi bon enseigner la programmation si on ne veut pas former des armées de programmeurs ?

La programmation, latin du futur ?

C’est un paragraphe de l’article qui a particulièrement retenu mon attention :

L’idée n’est donc pas de former de futurs programmeurs, mais d’initier les enfants à un langage programmatique** simple pour les familiariser avec la logique informatique. Les adeptes de cet enseignement ne tarissent pas d’éloges sur ses vertus pédagogiques. La programmation apprend à penser un problème jusqu’au bout, à construire des processus qui marchent en apprenant de ses erreurs. (…)

Et encore: le langage informatique enseigne à penser logiquement et systématiquement. «Peu de disciplines nécessitent une telle rigueur mentale», observe Jürg Kohlas. Bien sûr, les langues programmatiques** sont multiples et mouvantes. Mais quand on en a appris une, il est facile de se familiariser avec les suivantes.

Ça ne vous rappelle rien? Ne croirait-on pas entendre parler du latin? «La programmation est bel et bien un langage avec un vocabulaire, une grammaire, une syntaxe, acquiesce Juraj Hromkovic. Mais il y a une grosse différence avec les langues naturelles: la plupart des gens ne savent même pas qu’ils ont affaire à un langage.»

Dans mon esprit de lycéen des années 1980, la programmation n’avait rien, mais alors RIEN à voir avec la langue morte infligée aux fils d’avocats par des curés nostalgiques. Mais avec le recul, je partage le point de vue de gens qui connaissent le latin et la programmation comme Tyler Plack ,

Ecrire en latin ou programmer un ordinateur requièrent tous deux une compréhension qui dépasse la pensée humaine complexe et la simplifie. De tels processus sont ce qui nous permet de penser clairement; ils font de nous qui nous sommes.

Donc oui, il faut enseigner la programmation aux lycéens, même si “ça ne sert à rien”, comme le latin. Faut-il en faire une branche obligatoire du bac ? Certainement, au moins pour ceux qui ne font pas de latin.

Parce que combiner les deux peut donner des idées trop bizarres. Damian Conway par exemple en a été perturbé au point d’écrire un module définissant des alias latins pour tous les éléments du langage , ce qui permet de rendre ce code :

\[code lang="perl"\]

use Lingua::Romana::Perligata; maximum inquementum tum biguttam egresso scribe. meo maximo vestibulo perlegamentum da. da duo tum maximum conscribementa meis listis. dum listis decapitamentum damentum nexto fac sic nextum tum novumversum scribe egresso. lista sic hoc recidementum nextum cis vannementa da listis. cis.

\[/code\]

parfaitement valide et absolument équivalent à celui-ci:

\[code lang="perl"\]

print STDOUT ‘maximum:’; my $maxim = ; my (@list) = (2..$maxim); while ($next = shift @list) { print STDOUT $next, “\n”; @list = grep {$_ % $next} @list; }

\[/code\]

Et si après , la programmation permettait de moderniser l’enseignement du latin ?

Notes:

* l’expression est de Jean-Pierre Archambault, président de (qui a un site très moche)

** voilà bien la marque des pédagogues : surtout ne pas utiliser l’expression ” adopté par l’ensemble de la profession… Ou alors la journaliste n’a pas vérifié… (edit : c’est bien ça, Confirmé par anna Lietti…)

Références

Anna Lietti “ ” 2013, L’Hebdo No 34, p. 38-41
Jürg Kohlas, Jürg Schmid, Carl August Zehnder (2013). informatique@gymnase: Un projet pour la Suisse. NZZ Libro. ( )
Steve Furber “ ” January 2012, Royal Society
Académie des Sciences “ ", Rapport de l’Académie des sciences , Mai 2013
Jean-Pierre Archambault “ ”, 2012, l’Etudiant
" ” 2011, Framablog (trouvé grâce à l’image du T-shirt)
Tyler Plack “ ” (sur internet archive)
Damian Conway, “ ”, 2000, School of Computer Science and Software Engineering, Monash University (internet archive)

"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\]

Pavages aléatoires

Mon, 03 Oct 2011 00:00:00 +0000

Il devient de plus en plus difficile de choisir un carrelage original pour sa salle de bains.

Depuis le XVème siècle, 17 types de réguliers différents sont utilisés dans les décorations de l’ . En 1891, le mathématicien russe Evgraf Fedorov démontre que le nombre de pavages réguliers distincts vaut … 17 . Et ce n’est qu’entre 1968 et 1984 qu’on parvient à classifier toutes les formes de pavés possibles en 19 catégories . Depuis, les carreleurs ne peuvent se distinguer que par des motifs et des couleurs, plus par la géométrie.

En 1974, le crée un choc : il est possible de recouvrir le plan avec des pavés de deux formes différentes arrangés selon des règles rigoureuses, mais ne générant pas de motif périodique. En 1994, Radin et Conway en proposent un autre, le “ ”. Voilà pour le XXème siècle.

En 2011, c’est John Shier, un “artiste algorithmique” qui vient d’ouvrir tout grand la porte à une infinité de nouveaux pavages. Sa méthode permettent de couvrir le plan avec des pavés de presque n’importe quelles formes, mais de surface décroissantes , . Le principe semble tout simple : on place le plus grand pavé au hasard, puis le suivant en taille au hasard dans une surface libre et ainsi de suite.

Le pavage de John Shier le plus simple

Le problème est que si on réduit la taille des pavés trop vite on ne recouvre pas tout le plan, et si on réduit trop lentement, on risque d’être “coincé” à ne pas pouvoir placer un pavé. L’astuce consiste à attribuer au i-ème pavé une surface de A0/ic. Dans ce cas, la surface totale vaut :

\[mathjax\]$$A_{total}=A_{0}\sum_{i=0}^{\infty}i^{-c}$$

On reconnait en passant la , qui converge pour c>1. Grâce à cette formule, une fois choisi un c, la formule permet de calculer la surface A0 qui garantit qu’il ne restera plus un seul espace libre après avoir placé une infinité de pavés. En pratique on obtient d’excellent remplissages avec quelques milliers de pavés, un peu de patience et un bon programme. Paul Bourke décrit tout ceci en détail sur une page agrémentée de magnifiques exemples:

Il a même étendu la méthode à la 3D :

Pour ma part, j’ai réalisé la petite application ci-dessous en (disponible aussi avec son code source) pour expérimenter un peu cet algorithme que je trouve spectaculaire:

\[processing sketch="RandomTiling"\]

En pressant sur les touches 0,1,3,4,5,6 vous pouvez changer la forme des pavés à la volée, et la touche espace relance un pavage. Contrairement à Shier et Bourke, je ne pave pas un tore mais un rectangle, en prenant garde à ce que les pavés ne soient pas “coupés” par les bords. En plus je me suis amusé à implémenter les pavés en forme d’étoiles, en prévision d’une carte de Noël. Mignon, n’est-ce pas ? Bon, il reste pas mal de noir car la détection d’intersection entre étoiles est très lente, il faudrait améliorer ça.

Géantes rouges et naines bleues

ajout du 8/10/11 : j’ai présenté hier un décrivant la conception de ce programme.

edit du 20/9/13 : l’applet utilise maintenant Processing.js : drgoulu.com n’a plus besoin de Java !

Il y a encore (ou déjà…) 2 bugs connus, si ça vous dit de vous y mettre :

le pavage bloque parfois, surtout avec les triangles ou étoiles, il faut que j’ajoute un moyen d’ajuster la constante c…
des intersections entre cercles et polygones subsistent. Normal, j’ai eu la flemme d’implanter ça.

Une autre amélioration intéressante serait de remplir l’intérieur des pavés avec d’autres pavés…

Références:

Thérèse Eveilleau ” avec animations flash
Xavier Hubaut “ ”
John Shier “ ", Hyperseeing, summer 2011 issue, pp. 131-140, published by ISAMA (International Society of the Arts, Mathematics, and Architecture).
John Shier “
Paul Bourke “ ", July 2011

Le "Sleep sort"

Sun, 19 Jun 2011 00:00:00 +0000

Tout a commencé* par un : un anonyme propose un algorithme de tri en 2 lignes de code :

function f() {sleep "$1" echo "$1"} while [ -n "$1" ] do f "$1" & shift done wait

Lorsqu’il est appelé avec une liste de N nombres comme dans ./sleepsort.bash 5 3 6 3 6 3 1 4 7 , ce code lance un processus pour chacun des nombres n. Chaque processus effectue la fonction f, qui utilise la fonction pour attendre n secondes avant d’afficher le nombre n. Dans l’exemple, le 7ème processus n’attendra qu’une seconde avant d’afficher “1”, le 4ème et le 6ème attendront 3 secondes avant d’afficher “3” dans un ordre qui n’a aucune importance et ainsi de suite jusqu’au dernier processus qui affichera “7” après 7 secondes. L’utilisateur verra ainsi s’afficher progressivement les N nombres triés dans l’ordre croissant.

Depuis ce message on voit des implémentations de “Sleep sort” fleurir dans programmation en utilisant , et des , anglophones surtout pour l’instant.

Prétextant que ce programme mettrait plus de 11 jours à trier les deux nombres 1000000 et 673, certains considèrent le “sleep sort” comme un bon gag, ce qu’il est certainement à l’origine. Pour ma part j’ai de la . Voici pourquoi.

D’abord, ce code est simple et fait l’éloge d’une grande qualité du programmeur : la paresse. Faire quelque chose d’utile simplement en attendant, quoi de plus beau ? A ce titre il mérite amplement sa place à côté du dont en français, du ou des et sans intérêt, mais qui ont leur page Wikipédia.

Photo par Eben Regis sur flickr

Plus sérieusement, “Sleep sort” exploite de manière active l’écoulement du temps au lieu de le subir, ce qui est déjà intéressant en soi, mais pose également des questions intéressantes sur la .

Car le “génie” de cet algorithme, s’il vous avait échappé, est qu’il prend en apparence un temps proportionnel à max(n), le plus grand des nombres à trier, pour s’exécuter, plus un temps proportionnel à N pour créer les processus. Or les existants prennent un temps proportionnel à N.log(N). Il pourrait donc exister des cas où le “sleep sort” serait plus rapide. Mais est-ce vraiment le cas ?

Traitons d’abord de la partie la plus perceptible du temps d’exécution, l’attente de max(n) secondes. Sur les machines actuelles, , et on pourrait probablement passer aux microsecondes. En fait il faut simplement garantir que deux processus associés à deux nombres x et x+1 se réveillent dans le bon ordre et aient le temps de produire leur sortie sans perturber le réveil des processus suivants. Déjà ceci soulève plein de problèmes intéressants au niveau des systèmes d’exploitation, de l’accès aux ressources critiques etc. Mais quelles que soient les solutions techniques, il reste qu’on ne sait pas bien exprimer théoriquement la complexité d’un tel algorithme : en principe, une durée d’exécution proportionnelle à l’une des données conduit à une complexité O(1) supposée largement inférieure à O(N), ce qui n’est pas le cas en pratique ici.

Ensuite la partie “proportionnelle à N” dans laquelle on crée les N processus est elle vraiment O(N) ? En principe oui, mais il existe une partie invisible : la gestion interne de la fonction système “sleep”. Dans tous les systèmes d’exploitation que je connais (au moins deux…), “sleep” provoque l’insertion du processus dans une liste de tous les processus suspendus en attente de l’échéance d’un certain temps. Et pour éviter de parcourir toute la liste à chaque interruption du timer pour trouver quels processus doivent être réveillés, on la maintient triée dans l’ordre des réveils programmés. “Triée” ? Et oui… : à chaque instruction “sleep”, rencontrée le processus est inséré au bon endroit. “Inséré” ? Et re-oui… : l’exécution des N “sleep” revient à un “ ”, d’une complexité O(N²) rédhibitoire.

“Sleep sort” n’est donc pas un tri linéaire, du moins sur un ordinateur ayant beaucoup moins de N processeurs. Mais il soulève plein de questions intéressantes sur les algorithmes, les systèmes d’exploitation, l’architecture des ordinateurs et la psychologie des programmeurs. !

Note* : en fait l’idée est plus ancienne comme le montre ce post “ ” datant de 2006

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.

Calculateur d'(in)égalité

Sun, 11 Oct 2009 00:00:00 +0000

Les inégalités de revenu sont un sujet d’actualité politique brûlant. En Suisse, les viennent de lancer une initiative populaire visant à limiter le salaire maximal dans les entreprises à 12 fois le salaire minimal.Dans une petite boite c’est presque toujours le cas, mais plus on travaille dans une grande entreprise, plus on aimerait gagner en une année ce que gagne notre CEO en un mois…

C’est le problème du rapport max/min : il ne tient pas compte de tous les revenus intermédiaires. Dans une entreprise de 100 personnes, 98% des salaires sont compris entre celui du patron et celui de la technicienne de surface. Comment mesurer les inégalités de revenu en tenant compte de tous les revenus d’une société ?

La mesure d’(in)égalité des revenus la plus utilisée au niveau international s’appelle “coefficient (ou indice) de Gini”. J’en ai déjà parlé dans . L’indice de Gini vaut 0 si les revenus d’une société sont divisées de façon parfaitement égale, et 1 (ou 100%) si un seul esclavagiste empoche la totalité du revenu. En pratique, l’indice de Gini de la plupart des pays membre de l’OCDE se situe entre 0.5 et 0.4, mais les impôts réduisent les inégalités pour obtenir un Gini du revenu disponible entre 0.25 et 0.35 .

Le coefficient de Gini pourrait facilement être utilisé au niveau des entreprises. J’ai d’ailleurs créé une permettant de le calculer en ligne pour des entreprises de moins de 100 personnes*. C’est tout simple : copiez/coller les montants des salaires de votre entreprise dans la première colonne, triez-la dans l’ordre croissant, et voilà !

Le petit graphique associé (dont il faut changer l’échelle horizontale à la main au besoin) trace en bleu la qui montre la progressivité des revenus. L’indice de Gini est défini par la fraction de la surface entre la courbe bleue et la droite rouge par la surface sous la droite rouge.

En jouant avec cet outil, vous constaterez que l’initiative “1:12” des jeunesses socialistes n’implique pas du tout une distribution équitable des revenus. Comme le montrent les cas extrêmes ci-dessous, le coefficient de Gini peut varier énormément même si le salaire le plus élevé vaut 12x le salaire minimal:

société de 10 personnes ou les 9 employés ont un salaire égal et le patron un revenu 12 fois supérieur. Indice de Gini = 0.52

société de 10 personnes ou 9 cadres ont un salaire égal, et un employé un salaire 12x moins élevé. Indice de Gini = 0.1

Pour des revenus réellement équitables, il faudrait que le coefficient de Gini des entreprises corresponde, ou soit même inférieur à celui du pays considéré. Ceci laisse encore une grande flexibilité à la politique salariale. Voici par exemple quelques distributions de revenus donnant un indice de Gini = 0.33, le même que celui de la Suisse entière (avant impôts):

10% du personnel touche un salaire 6x supérieur aux 90%
50% du personnel touche un salaire 4x supérieur aux autres 50%
des salaires : 10% touchent un salaire de base, 10% touchent 2x plus, 10% touchent 3x plus etc jusqu’aux 10% qui touchent 10x le salaire de base:

distribution uniforme des revenus : Gini = 0.33

On voit au passage que la courbe de Lorenz permettent d’ illustrer de manière fine la politique salariale des entreprises. En particulier, les différences de statut entre employés provoquent des “cassures” dans la courbe, alors que des revenus abusifs dans le haut de l’échelle sont détectables par la pente de la courbe à droite.

Il serait très intéressant de connaitre le coefficient de Gini des entreprises. je n’en ai trouvé aucun sur internet, pourtant je suis persuadé que les grandes entreprises (et les grands patrons) pourraient défendre leur politique de rémunération en publiant ce chiffre, qui est beaucoup plus parlant que le rapport max/min ou le montant total de la rémunération de la direction.

Si vous connaissez celui de votre entreprise ou si vous le calculez à l’aide de ma , je vous serais très reconnaissant de le communiquer à l’aide des commentaires ci-dessous. Pas besoin de nommer l’entreprise, le secteur d’activité et la région suffisent. Merci d’avance !

Note : cette est mise à disposition gratuitement uniquement pour utilisation privée, non commerciale. Je m’en réserve tous les droits pour les autres usages. Veuillez me contacter en déposant un commentaire ci-dessous si vous envisagez utiliser cette feuille professionnellement.

La fraternité des nombres

Mon, 28 Sep 2009 00:00:00 +0000

Vu l’autre jour sur un blog¹ une “question bête”, donc intrigante : existe-t-il des nombres entre lesquels les mathématiciens ne connaissent aucune relation ?

La question est “bête” puisqu’on peut toujours trouver une relation entre deux nombres entiers. Mais elle m’a rappelé ma quête initiée avec les : tous les nombres ont de nombreuses propriétés répertoriées en particulier dans l’ de Sloane, mais certains en ont nettement que d’ .

En utilisant la même approche (la base de données de Sloane digérée par quelques lignes de Python), j’ai établi le lien de “fraternité” entre les entiers de 1 à 1024, en comptant pour chaque paire (a.b) possible le nombre de suites comportant ces deux nombres, que j’appelle la fraternité f(a,b).

Par exemple, 456 et 789 ont une fraternité f(456,789) = 32, car et partagent donc autant de propriétés répertoriées.

Les nombres les plus fraternels sont évidemment , qui sont présents dans 133529 séries répertoriées à ce jour. A l’inverse, **les deux plus petits entiers qui ne partagent aucune propriété sont **².

sont les plus petits nombres ayant une seule propriété commune, en l’occurence

J’ai représenté les fraternités f(a,b) pour a et b variant de 1 à 1024 dans l’image ci-dessous. Le point (1,1) est en bas à gauche. Les fraternités f(a,b)>100 sont représentées par des pixels rouges et les fraternités inférieures à 10 sont en bleu foncé. Les quelques pixels noirs dénotent les fraternités f(a,b)=0.

fraternité f(a,b) des nombres entre 1 et 1024. cliquer pour agrandir.

On remarque l’apparition de quelques motifs:

les lignes horizontales et verticales claires correspondent à des nombres particulièrement , les sombres aux
les lignes claires à 45° sont plus surprenantes. Elles semblent indiquer que des nombres consécutifs ont tendance à être plus proches d’autres nombres consécutifs séparés par des constantes. Je m’attendais à voir apparaître des lignes à 30° et 60° liant les nombres à leurs doubles, mais ce n’est pas le cas.
Sur la diagonale (coloriée en rouge par convention), on distingue des petites taches autour de groupes de nombres particulièrement intéressants comme les fortement composites (160, 320) et les puissance de 2 (256, 512), qui forment aussi des taches aux intersections hors diagonale.
Les motifs les plus étranges sont les groupes de 9 points clairs visibles le long des bords bleus, et en particulier au coin supérieur droit. Ils correspondent aux nombres 1010±10 et 110±10, ce qui peut s’expliquer par les nombreuses suites faisant intervenir des nombres binaires, mais on en trouve aussi à 210±10. Est-ce l’effet du ternaire, ou d’autre chose ?

Résultat provisoire de ma recherche aussi excitante qu’inutile : les nombres ne sont décidément pas tous égaux devant les mathématiques.

Notes:

je ne retrouve plus la source de la “question bête”. Elle a été posée il y a une semaine sur un blog… Si vous savez où, merci de me l’indiquer en commentaire…
Le moteur de recherche de l’Encyclopédie de Sloane peut soit trouver des termes consécutifs dans la série, soit des nombres présents dans tout l’article dédié à chaque suite. C’est pourquoi la recherche de fournit plusieurs résultats, mais si vous regardez bien, les nombres 48 et 857 ne sont jamais présents ensemble dans les séries.

Combien de nombres palindromes < N ?

Sat, 26 Sep 2009 00:00:00 +0000

Les problèmes du devenant vraiment très ardus, j’ai été content de trouver un petit challenge intéressant : déterminer rapidement le nombre de nombres palindromes inférieurs à un maximum donné.

un nombre palindrome

Un se lit indifféremment de gauche à droite ou de droite à gauche, comme 1234321 ou 567765. Outre leur aspect esthétique, ces nombres ont aussi des .

La première idée qui vient à l’esprit est de les compter (c’est du ):

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; var i:Integer; s:string; begin Result:=0; for i := 1 to maxNumber do begin s:=IntToStr(i); if s=ReverseString(s) then Inc(Result); end; end;

\[/sourcecode\]

Ca marche, mais c’est très lent : pour maxNumber=1000000000, il faut un milliard de conversions en chaine de caractères, un milliard d’inversions de chaîne, et un milliard de comparaisons. Or le résultat n’est que de 109998. Comme l’ (mais c’est de moi) :

Si ta boucle ne fait rien 99% du temps, c’est que tu n’utilises pas le bon algorithme.

De plus, notre boucle génère tous les nombres palindromes sous forme de chaine, et on les jette.

Si tu jettes 99% des résultats, c’est que tu n’utilises pas le bon algorithme.

Une autre approche, que beaucoup utilisent avant même de programmer, voire de réfléchir, est de . C’est une excellente approche. On trouve immédiatement une , avec une formule qui offre sur un plateau le nombre a(n) de nombres palindromes inférieurs à 10n

La formule n’est valable que pour n entier, mais on peut tout de même la convertir en une petite fonction Delphi:

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const pow10:array

\[0..9\]

of integer=(1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000); var n:Integer; begin n:=Round(log10(maxNumber)); if Odd(n) then Result:=11*pow10

\[(n-1)div 2\]

-2 else Result:=2*pow10

\[n div 2\]

-2; end;

\[/sourcecode\]

Comme il s’avère que le ne teste les algorithmes proposés qu’avec une puissance de 10, vous avez ci dessus une solution victorieuse, mais typique de la programmation agile : elle ne fonctionne (bien) que pour les tests ;-)

Tentons maintenant de rendre notre programme correct quel que soit N, si possible sans le ralentir. On va même commencer par le rendre encore plus rapide en poussant le vice de la programmation agile (= paresse) encore plus loin:

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const A050250:array

\[0..9\]

of integer=(0,9, 18, 108, 198, 1098, 1998, 10998, 19998, 109998); begin Result:=A050250

\[Round(log10(maxNumber))\]

; end;

\[/sourcecode\]

Le vecteur contient directement les résultats de la formule pour n=(0),1,2,..,9. Son nom provient de .

L’algorithme ci-dessous commence par utiliser cette série pour compter les palindromes inférieurs à la puissance de 10 juste inférieure à maxNumber, puis considère successivement les chiffres de maxNumber en partant du plus significatif et compte le nombre de palindromes possibles sur les digits intermédiaires.

Par exemple pour maxNumber=5832476 :

on compte 1998 palindromes inférieurs à 1000000, le plus grand étant 999999
on ajoute (5-1) fois le nombre de palindromes de 5 chiffres, soit 1000 (de 000|00 à 999|99), ce qui donne le nombre de palindromes jusqu’à 4999994
on ajoute 8 fois le nombre de palindromes de 3 chiffres, soit 100. On a donc compté les palindromes jusqu’à 5799975
on ajoute 2 fois les 10 nombres possibles au centre, ce qui compte jusqu’à 5829285
reste à ajouter les (2+1) nombres palindromes obtenus en changeant le chiffre central : 5830385, 5831385 et 5832385

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const A050250:array

\[0..18\]

of integer =(0,9, 18, 108, 198, 1098, 1998, 10998, 19998, 109998, 199998, 1099998, 1999998, 10999998, 19999998, 109999998, 199999998, 1099999998, 1999999998); const pow10:array

\[0..9\]

of integer =(1,10,100,1000,10000,100000, 1000000,10000000,100000000,1000000000); var n,i,j,k:Integer; d:array

\[0..18\]

of integer; // digits begin i:=0; n:=maxNumber; while n>0 do begin // extract digits d

\[i\]

:=n mod 10; n:=n div 10; inc(i); end; n:=i-1; // n=Trunc(log10(maxNumber)) Result:=A050250

\[n\]

; i:=n; j:=0; k:=n div 2; dec(d

\[n\]

); // because we counted palindromes to 1000..00 while i-j>=2 do begin // loop from outer digits to inner Result:=result+d

\[i\]

*(pow10

\[k\]

); dec(i); inc(j); dec(k); end; inc(Result,d

\[i\]

); // handle 1 or 2 center digits if d

\[j\]

>=d

\[i\]

then inc(Result); end;

\[/sourcecode\]

Cet algorithme étant nettement plus rapide et compact que les solutions existantes du challenge, je viens de le soumettre au bien qu’il y ait encore une petit bulle… Pour certains maxNumber “rares”, le résultat est 1 de trop. Saurez-vous trouver pourquoi avant moi ?

la Résurrection du Jeu de la Vie

Sun, 29 Mar 2009 00:00:00 +0000

Le imaginé par en 1970 est un automate cellulaire célébrissime pour au moins deux raisons:

Un "canon à planeurs"

A partir de règles toutes simples, le jeu de la vie génère une “vie” artificielle étrangement complexe et imprévisible, posant toutes sortes de questions intéressantes
Le Jeu de la Vie étant très facile à programmer, des générations d’étudiants ont codé des programmes “Life” dans tous les langages imaginables.

Après une flambée d’intérêt dans les années 1980 où on a même vu apparaitre des processeurs spécialisés dans l’exécution d’automates cellulaires, le soufflé est retombé dans la décennie suivante car la simulation de grands automates demandait beaucoup de puissance de calcul et de mémoire.

Mais comme nous l’apprend Jean-Paul Delahaye dans le dernier “Pour la Science” , il y a du nouveau. En 2005 est apparu “ ”, un logiciel Open Source utilisant “ ", un algorithme accélérant le calcul des automates cellulaires d’une manière phénoménale. Hashlife a été imaginé en 1984 déjà par , un des premiers “hacker” du Xerox Park de Palo Alto. Mais pour une étrange raison, ce n’est qu’en 2004 Tomas Rokicki l’a implanté en C et décrit dans un article intitulé “un algorithme pour compresser le temps et l’espace” .

Hashlife combine en effet deux techniques de programmation :

une partition de l’espace qui permet d’une part d’ignorer les grandes zones de cellules vides et d’autre part de reconnaitre les copies identiques de groupes de cellules
la “ ”, qui consiste à mémoriser des résultats précédemment calculés afin de les restituer immédiatement lorsque la même situation se représente.

Ainsi, hashlife ne calcule qu’une seule fois l’évolution d’un groupe de cellules qui serait présent à des milliers d’exemplaires dispersés sur un immense jeu de la vie, et n’a besoin de mémoire que pour stocker chacune des étapes d’un cycle au lieu de millions de cellules.

Hashlife parvient ainsi à calculer des milliers de générations par seconde de “Jeux de la Vie” comportant 10^{50 cellules sur un PC ordinaire doté de 10}9 octets de mémoire !

Voici par exemple “ ” en action sur le “breeder”, la première structure générant un nombre de cellules augmentant comme le carré du nombre de générations :

On voit comment un groupe de “fusées” se déplace vers la droite en générant des “canons à planeurs”. En quelques secondes, 400'000 générations ont été calculées (même pas à vitesse maximale) , générant 160 millions de cellules actives.

Cette vitesse permet de visualiser confortablement d’autres structures extraordinaires découvertes récemment, comme les “métacellules”:

On voit ici un tableau de 15x15 métacellules, dont chacune se comporte comme une cellule du Jeu de la Vie ! En 30'000 générations environ, chaque métacellule compte le nombre de ses voisins “vivants” et devient elle-même vivante en se remplissant de planeurs en suivant la règle de Conway !

Le “Jeu de la Vie” est donc capable d’exécuter un programme jouant au “Jeu de la Vie”. Mais quels autres programmes peut-il exécuter ? On connait depuis 1984 des structures calculant les nombres premiers, et d’autres “écrivant” en clair comme celle-ci :

Mais en 2000, Paul Rendell a réussi a créer une “ ” en Jeu de la Vie , ce qui signifie que ce petit jeu aux règles extraordinairement simple est capable, avec une astucieuse programmation, de réaliser toutes les opérations d’un ordinateur usuel.

Outre le jeu de la Vie, Golly peut exécuter d’autres automates cellulaires en utilisant le fantastique algorithme Hashlife, notamment , un système simulant les circuits électroniques digitaux.

“Hashlife” est bien un algorithme qui compresse l’espace et le temps, comme le dit Rokicki, et il est même d’un usage assez général. Je ne serais pas étonné s’il trouvait prochainement des applications “sérieuses”, en simulation notamment.

J’adore les rubriques de Jean-Paul Delahaye dans “Pour la Science”. Surtout celle du mois prochain…

Références:

Jean-Paul Delahaye “ ”, Pour la Science, avril 2009, p. 86-91
Tomas G. Rokicki “ ”, Dr. Dobbs Journal, avril 2006
William Gosper “Exploiting Regularities in Large Cellular Spaces”, 1984, Physica D. Nonlinear Phenomena, Vol 10, pp. 75-80
Paul Rendell " ”, 2000
Paul Callahan “Wonders of Math : ” sur Math.com
, un blog dédié aux nouvelles découvertes sur le Jeu de la Vie
Un “ ” en Java, utilisant l’algorithme Hashlife implanté dans ce langage, en open source.
David Bau “ ”, une implantation (simplifiée) de Hashlife en Python

Programmer pour le fun

Mon, 23 Feb 2009 00:00:00 +0000

Amis des casse-tête mathématiques ardus et de la programmation d’algorithmes optimisés, bonjour!

Je viens de découvrir , et j’ai honte de ne pas l’avoir trouvé avant. Ce site propose 233 problèmes (et environ un de plus chaque semaine environ) pouvant parfois être résolus avec un papier et un crayon propulsé par un cerveau en ébullition, mais pour la plupart requièrent quelques lignes de code bien pensées et un stupide esclave électronique pour les exécuter.

Une fois inscrit sur le site, vous pouvez soumettre vos solutions aux problèmes dans l’ordre qui vous plait et chaque bonne réponse vous apporte instantanément:

la possibilité d’accéder à un forum où les solutions sont comparées et discutées. C’est en général là qu’on commence à avoir mal au front, quand on découvre des algorithmes 1000x plus rapides que ceux qu’on s’est escrimé à mettre au point, ou pire, la petite formule qui tue…
un bon point. Après 25 bonnes réponses vous entrez dans le tableau des et pouvez espérer rejoindre un jour la qui ont résolu tous les problèmes jusqu’ici.

Il faut dire que les premiers problèmes sont relativement simples, par exemple les 17 que j’ai déjà résolus sont :

additionner tous les entiers intérieurs à 1000 qui sont multiples de 3 ou 5
trouver la somme de tous les nombres pairs de la inférieurs à 4'000'000
trouver le plus grand facteur premier de 600'851'475'143
trouver le plus grand palindrome formé par le produit de 2 nombres de 3 chiffres
quel est le plus petit nombre divisible par tous les entiers de 1 à 20 ? (facile. celui là je l’ai fait à la main)
quelle est la différence entre le carré de la somme des 100 premiers entiers et la somme du carré de ces même nombres ?
trouver le 10001ème nombre premier
trouver le plus grand produit de 5 chiffres consécutifs dans un nombre à 1000 chiffres
trouver le seul dont la somme a+b+c=1000
calculer la somme des nombres premiers inférieurs à 2'000'000
quel est le premier ayant plus de 500 diviseurs ?
quels sont les 10 premiers chiffres de la somme de 100 nombre de 50 chiffres donnés?
trouver le nombre inférieur à 1'000'000 générant la plus longue
en partant d’un coin d’une grille de 20x20, combien y’a-t-il de chemins au coin opposé ? ( …)
quelle est la somme des chiffres de 21000?
quel est le premier terme supérieur à 101000 de la suite de Fibonacci ? (et si je vous disais qu’on peut le trouver sans calculer les termes précédents ?)
trouver la somme des chiffres de 100! (factorielle…)

Certains de ces problèmes exigent de pouvoir manipuler de grands nombres, ce qui est une force du langage , que j’aime de plus en plus. On peut par exemple obtenir la somme des chiffres de la factorielle de 100 en une seule ligne* combinant la et la fonction

reduce(lambda x, y: x + y, [int(i) for i in str(reduce(lambda x, y: x * y, range(1, 100)))])

Bon, jusqu’ici j’ai fait le facile : même avec une approche un peu brutale, on s’en sort. Mais rapidement la complexité fait son apparition au carré : au niveau mathématique et au niveau algorithmique, condamnant le programmeur peu subtil à patienter des minutes, des heures ou des siècles devant un sablier virtuel …

Je vois encore quelques problèmes liés à des sujets déjà abordés sur Dr.Goulu comme:

trouver le polynôme _n_² + an + b, où|a| < 1000 et|b| < 1000 qui produit le plus de
quel nombre premier inférieur à 1'000'000 est la ?
combien existe-t-il de inférieurs à 10'000 ?

Il y a encore environ entre 20 et 50 problèmes que j’espère pouvoir résoudre à raison d’un par soirée.

Après, ce sera l’enfer mais j’espère vous y retrouver, ami lecteur … (insérer un rire ici)

Note* dans le forum on découvre une solution en 13 caractères seulement, en évidemment: +/".“0”:!100x

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\]

Le Problème à N corps

Sun, 16 Nov 2008 00:00:00 +0000

Le “problème à N corps” consiste à déterminer le mouvement de N masses sous l’effet des forces d’attraction gravitationnelles entre elles.

Pour N=2, Newton savait déjà que les décrivent des ellipses autour de leur centre de gravité commun.

Pour N=3, : une toute petite différence dans les positions et vitesses initiales des corps pouvait causer de très importantes différences dans la trajectoire des corps. Cependant, malgré ce que beaucoup croient, il existe une solution analytique au problème des trois corps découverte en 1909 par . Elle n’est cependant pas utilisable en pratique pour des calculs.

Pour plus de 3 corps, il n’existe pas de solution analytique. Ceci signifie entre autres qu’il n’est pas possible de démontrer la stabilité d’un système avec quelques corps, comme le Système Solaire par exemple. Des mathématiciens comme ou s’y sont cassés les dents : rien ne prouve que les planètes suivront toujours leurs orbites actuelles dans quelques centaines de millions d’années. Encore moins qu’un astéroïde viennent percuter notre belle planète beaucoup plus tôt.

Simulation du Système Solaire sur Univers Sandbox, N~20

Il est aujourd’hui facile de simuler quelques millions d’années d’évolution du Système Solaire sur un PC, par exemple avec , le chouette programme dont j’ai . Comme on connait avec une très grande précision la position, la vitesse et la masse des planètes et de leurs principaux satellites, on estime que l’on peut calculer leur position dans 5 millions d’années à 150m près. Pour arriver à cette précision, mais aussi tout simplement pour réaliser une simulation réaliste, il faut tout particulièrement veiller à la utilisée, pour garantir la conservation de l’énergie totale du système. Selon , la méthode de donne les meilleurs résultats.

D’autre part, pour chacun des N corps, il faut calculer les N-1 forces exercées par les autres corps. Au total, il faudra calculer

\[N.(N-1)\]

/2 forces (le /2 vient du fait qu’il suffit de ne calculer qu’une fois la force entre deux corps). On dit que la complexité est O(N²) : il faut effectuer un nombre d’opérations proportionnel au carré de N. Pour quelques dizaines de corps, ça ne pose aucun problème, mais si l’on veut simuler des galaxies ou même la collision de galaxies avec N=1'000'000, on se retrouve avec mille milliards de forces à évaluer, ce qui nécessite beaucoup de temps de calcul.

Simulation de la future collision de la Voie Lactée et d’Andromède, N=100'000'000

On pourrait se dire qu’une petite étoile à un bout de la galaxie n’attire pratiquement pas une autre petite étoile très distante, mais négliger cette force n’est pas une bonne idée. D’une part, l’énergie totale du système ne serait plus conservée, et d’autre part il faudrait trouver un critère permettant de savoir quelles forces sont négligeables, sans les calculer.

ont proposé en 1986 un algorithme dont la complexité est O(N.log N). Pour N=1'000'000, il n’y a environ que 20'000'000 de forces à évaluer, ce qui rend le calcul possible. L’algorithme consiste à diviser l’espace en une structure arborescente appelée et à y répartir les corps. On ne calcule les forces qu’entre les corps situé dans la même zone de l’octree, puis l’algorithme calcule les interactions entre les zones. Reste une difficulté : en se déplaçant, les corps changent de zone, et l’algorithme nécessite d’adapter l’octree de l’adapter à la distribution des corps.

interaction de 2 amas de 50 galaxies. N=160'000

Dès 1987, a développé un algorithme baptisé “ ” (FMM), dont la complexité est O(N) seulement, et qui ne nécessite pas d’adaptation de la division de l’espace utilisée. Il est assez facile d’ , mais en 3D l’interaction entre zones est beaucoup plus complexe.

La FMM est considérée par certains comme l’un des algorithmes les plus importants du XXième siècle, car il peut être appliqué à des problèmes beaucoup plus généraux que les N corps, comme certains problèmes de ou de . Inutile de dire que je vais regarder ça de plus près …

Références:

, le logiciel développé par Barnes et Hut, site avec énormément de liens sur le domaine
Dossier “ ” sur AstroSurf
sur la Wikipedia
à Berkeley
: code VPython
sur Wikipedia
Guy Blelloch and Girija Narlikar “ ” Parallel Algorithms. Series in Discrete Mathematics and Theoretical Computer Science, Volume 30, 1997.
, une librairie de simulation N corps parallélisée sur GPU (processeur graphique)
: comparaisons et implémentation sur super ordinateurs

Logiciels N corps sur PC:

: le plus beau et le plus fun
: utilise l’alogrithme de Barnes Hut
, un peu ancien

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 …

Sommes Egales de Nombres Premiers Consécutifs

Tue, 03 Jun 2008 00:00:00 +0000

Le quatrième et dernier problème de la mérite un article à lui tout seul. (J’ai parlé des trois autres dans )

Il s’agit de trouver le plus petit P qui soit en même temps :

la somme de 9 nombres premiers consécutifs
la somme de 119 nombres premiers consécutifs
la somme de 215 nombres premiers consécutifs
et la somme de 675 nombres premiers consécutifs !

(les nombres 9, 119, 215 et 675 sont différents pour chaque concurrent…)

C’est étonnant, mais beaucoup de nombres premiers sont des sommes de nombres premiers consécutifs (abrégé SNPC ci après), par exemple :

5+7+11+13+17 = 53 7+11+13+17+19 =67 11+13+17+19+23 =83

De plus, il est fréquent qu’un même nombre premier soit égal à plusieurs SNPC. Par exemple sur on mentionne:

34421 = 269 + … + 709 (71 nombres premiers) 34421 = 1429 + … + 1571 (23 nombres premiers) 34421 = 3793 + … + 3853 (9 nombres premiers) 34421 = 4889 + … + 4937 (7 nombres premiers) 34421 = 11467 + … + 11483 (3 nombres premiers)

Le nombre P recherché n’est donc peut-être pas très grand, d’autant que la somme des 675 premiers nombres premiers ne vaut que 1'578'242. Il n’y a probablement pas besoin de calculer en “bigint”, les entiers sur 32 bits, voire 64 disponibles avec n’importe quel langage de programmation devraient suffire. Par contre, il est pratique de disposer de fonctions prédéfinies pour manipuler des nombres premiers, c’est pourquoi j’ai choisi d’utiliser .

Les fonctions suivantes suffisent pour résoudre le problème posé: (code modifié le 4/6/8 suite aux commentaires de b0z0)

\[gist id="0e35207dedf4e337c937"\]

La fonction SCP (Sum of Consecutive Primes) renvoie la somme des n nombres premiers consécutifs en commençant par le i-ème nombre premier en utilisant la fonction prédéfinie Prime

\[j\]

qui renvoie directement le j-ème nombre premier.

Cette somme n’étant pas forcément un nombre premier, la fonction PSP (Prime Sum of Primes) appelle répétitivement SCP en augmentant i jusqu’à ce que la somme soit un nombre premier, vérifié grâce au test de primalité , une fonction non triviale bien utile ici. Pour une raison expliquée plus bas, PSP renvoie une paire de résultats : la somme, et l’indice du premier nombre premier de la somme.

Enfin, la fonction CPSP (Compound Prime Sum of Primes) implante l’algorithme que j’ai inventé pour la circonstance. Elle prend en paramêtre la liste des nombres de nombres premiers consécutifs sommés. Pour résoudre notre problème, on appellera CPSP

\[{675, 215, 119, 9}\]

on initialise une liste p avec les n résultats de PSP obtenus pour chacun des nombres de nombres premiers consécutifs à additioner. Ainsi, pour CPSP \[{675, 215, 119, 9}\], p est initialisé à {{1583291,2},{149993,15},{41641,10},{127,2}}. Autrement dit, 1583291 est le plus petit nombre premier qui soit la somme de 675 nombres premiers consécutifs, et cette somme commence avec le 2ème nombre premier. 149993 est le plus petit nombre premier qui soit la somme de 215 nombres premiers, en commençant par le 15ème, et ainsi de suite
par paresse (qualité indispensable chez les programmeurs…) , la détection de la fin de l’algorithme est réduite au minimum vital : dès que la liste p n’est plus modifiée par l’algorithme, on arrête
Pour chaque élément de la liste p en commençant par le deuxième, on regarde si la somme est inférieure à la somme du premier indice. Si c’est le cas, on calcule une somme supérieure en incrémentant l’indice correspondant, jusqu’à ce que la somme soit égale à la première, ou la dépasse. Après cette étape, la liste p devient {{1583291,10},{1600981,840},{1589563,1526},{1584829,15997}} : on voit que les sommes 2,3 et 4 ont dépassé la somme 1
Si la somme 1 est plus petite que la somme 2, on augmente la somme 1 jusqu’à ce que’elle atteigne ou dépasse la somme 2. On arrive ainsi à {{1623917,10},{1600981,840},{1589563,1526},{1584829,15997}}. On boucle au point 2

Les trois dernières boucles donnent les listes suivantes qui montrent bien le fonctionnement de l’algorithme:

{{8256361,1127},{8112103,3883},{8115539,6728},{8112787,71376}} {{8275409,1130},{8259353,3947},{8264171,6833},{8256383,72536}} {{8275409,1130},{8275409,3954},{8275409,6841},{8275409,72696}}

et voilà : 8'275'409 est égale à la somme des:

675 nombres premiers consécutifs à partir du 1130-ème (9109)
215 nombres premiers consécutifs à partir du 3954-ème (37339)
119 nombres premiers consécutifs à partir du 6841-ème (68821)
9 nombres premiers consécutifs à partir du 72696-ème (919421)

Quelques minutes pour choisir le bon outil (Mathematica) + quelques minutes de programmation + 30 secondes de calcul, c’est gagné !

Recrutement et Casse-Tête

Sat, 17 May 2008 00:00:00 +0000

Si vous souhaitez travailler chez Google ou facebook, voici un petit tuyau : cultivez l’art de résoudre des casse-tête, et montrez vos talents sur internet.

, on testera votre raisonnement logique dès les premières minutes du premier interview téléphonique, puis on vous cuisinera sur de nombreux autres problèmes plus mathématico-informatiques lors des interviews suivants. En parallèle, vous recevrez un e-mail qui vous incitera à participer aux , un site extraordinaire sponsorisé par de nombreuses entreprises qui recherchent à la fois des solutions originales à des problèmes très pointus et des développeurs de haut niveau. Un très bon endroit pour se faire remarquer (pas seulement par Google) si vous êtes un mordu d’algorithmes. Dommage qu’on doive s’engager à ne pas parler des problèmes à l’extérieur du site TopCoder, parce qu’ils sont très jolis.

Google lance aussi des “chasses au trésor” sur internet. Là je viens de commencer à participer à , qui commence très fort: si le robot ci-dessous ne peut aller que vers la droite ou vers le bas, combien y’a-t-il de chemins distincts qui le mènent au but ?

Vous avez trouvé ? En comptant à la main ? Bien. Mais en fait, pour la chasse au trésor, il faut répondre pour un damier de 56x32 cases (le nombre change pour chaque participant) … Dans ce cas, la réponse est 232059241971866600926656, ce qui suppose de et de disposer d’une bonne calculatrice …

Si c’est facebook qui vous tente, il faut visiter , chosir un des jolis problèmes qui s’y trouvent, le résoudre avec un programme en C++, Java, JavaScript, OCaml/SML, Perl, PHP ou Python, ce qui montre bien que les langages de programmation n’ont que peu d’importance pour ceux qui savent ce qu’est un algorithme, et que toutes ces jolis sites web ne sont que du vernis. Ensuite, il faut envoyer la réponse à { (0xFACEB00C » 2) en décimal } @ facebook.com. .

Génération de polices bitmap de haute qualité

Sat, 10 May 2008 00:00:00 +0000

Voici comment générer rapidement et automatiquement des polices de caractères bitmap avec canal alpha, donnant un anti-aliasing parfait quel que soit la texture de fond utilisée. Toutes les polices vectorielles peuvent être utilisées et combinées avec une infinité d’effets graphiques.

Le logiciel réalisant 99% du travail est , un programme de traitement d’images open-source gratuit que je considère comme un “Photoshop sans GUI” : aussi puissant que l’outil d’Adobe, ImageMagick s’utilise uniquement depuis un autre programme, voire simplement la ligne de commande du shell. A installer d’urgence.

Voici par exemple le petit fichier batch qui crée quelques fichiers contenant des mots, dont le fichier font.png contenant le mot “font” de l’image ci-dessus :

@echo off rem Function: Create transparent background, aliased texts from a list of words rem Author: Philippe Guglielmetti rem Requires: ImageMagick v.6 or later (www.imagemagick.org) set texts=OK Abort Cancel font "This is Great !" set params=-background none -font Bauhaus-93 -pointsize 72 -density 300 -fill blue -blur 0x5 for %%a in (%texts%) do convert.exe %params% label:%%a %%a.png set texts= set params=

Les “params” définissent la police à réaliser:

-background none est essentiel pour dessiner la police sur un fond transparent (canal alpha)
-font Bauhaus-93 définit la police vectorielle à utiliser (dont le nom n’est parfois pas identique à celui apparaissant dans le dossier “Fonts” de Windows…)
-pointsize 72 -density 300 spécifient que la police doit faire 72pt de haut à 300dpi. La taille du bitmap sera donc supérieure à l’écran, mais il pourra être imprimé ou utilisé comme texture dans un jeu 3D ou une démo Demoniak3D avec un résultat d’excellente qualité
-fill blue -blur 0x5 sont deux petits effets de base : on remplit le caractère en bleu, et on adoucit le tracé de la lettre, qui est d’un pixel de noir par défaut. Ceci crée des pixels semi-transparents au bord des caractères, ce qui permet une découpe parfaite des caractères quel que soit le fond, comme on le voit sur le zoom ci-contre:

Pour placer la police sur la texture de fond afin de vérifier sa qualité, on utilise un autre module d’ImageMagick;

composite.exe -tile back.png -compose Dst_Over font.png test.jpg

Une fois ce test réalisé, on peut s’attaquer à la génération de tous les caractères de la police. Si seuls quelques caractères sont nécessaires, on peut utiliser le batch ci-dessus en définissant par exemple

set texts=0 1 2 3 4 5 6 7 8 9

Mais ceci est fastidieux pour une police complète, et pour des raisons de programmation de l’application finale, il peut être utile de nommer les fichiers d’après le code ASCII de chaque caractère. Comme cette fonctionnalité n’est pas disponible dans le langage de commande Windows, il faut programmer ceci dans un langage évolué. Par exemple en LUA:

params="-background none -font Bauhaus-93 -pointsize 72 -density 300 -fill white -blur 0x5 " for i=32,167 do os.execute("convert.exe "..params.."label:"..string.char(i).." "..i..".png") end

Ces 2 lignes génèrent automatiquement 130 fichiers de belles lettres prêtes à être utilisées comme textures dans votre jeu. A noter que ces fichiers pèsent déjà 10 Mb au total, soit plus que l’exécutable d’ImageMagick : il peut donc être intéressant d’inclure ImageMagick à votre produit et de l’utiliser pour créer les polices nécessaires lors de l’installation plutôt que d’alourdir votre distribution…

Enfin, si vous trouvez les polices ci-dessus un peu trop carrées, visitez qui vous donnera une petite idée des effets possibles, et explorez pour une vision plus complète.

Google ouvre son infrastructure

Tue, 08 Apr 2008 00:00:00 +0000

Stupéfaction : Google vient de permettre à 10'000 programmeurs d’utiliser , un environnement permettant de développer (en Python) des applications qui fonctionneront directement sur les serveurs de Google, en utilisant certaines technologies propriétaires de Google, et tout ça gratuitement.

Jusqu’ici, Google gardait jalousement sa technologie permettant de stocker et d’indexer pratiquement toute l’information du web sur des milliers d’ordinateurs disséminés à travers le monde. On connaissait cependant l’architecture et les principales briques du système :

le (GFS), permettant de gérer d’énormes fichiers répartis et redondants
, la base de données “orienté colonnes” et reposant sur GFS. Bigtable est utilisé par énormément d’applications Google, l’index du moteur de recherche n’étant pas le moindre : c’est Bigtable qui retrouve en quelques secondes toutes les pages internet contenant des mots donnés…
est un programme général permettant de faire simultanément 2 choses avec un très grand nombre de données : une transformation de chaque donnée (Map) et une agrégation des résultats (Reduce). MapReduce sert par exemple à compter le nombre de liens pointant vers chaque page (web link graph reversal), information utilisée pour calculée le .

Tout ceci est expliqué cette passionnante vidéo d’une heure, à regarder absolument si vous voulez comprendre.

Pourquoi Google met-il ceci à disposition gratuitement ? Lorsqu’on sait qu’ ils n’arrivent pas à recruter autant qu’ils aimeraient, que les 10'000 comptes ont été réservés en quelques minutes, et qu’ils ont les moyens de contrôler puis de racheter toute application intéressante qui résulterait de cette initiative, on peut commencer à apprécier ce coup à sa juste valeur…

sources:

Michael Arrington “ , TechCrunch, 5 avril 2008
Fay Chang & al, “ ”,
Jeffrey Dean and Sanjay Ghemawat, “ ”, OSDI 2004

Proce55ing

Thu, 03 Apr 2008 00:00:00 +0000

est un langage de programmation, et même un environnement de développement d’applications graphiques temps réel interactives. Créé initialement par et pour des applications de visualisation de données, Processing est également apprécié de créateurs comme qui en tirent des oeuvres graphiques magnifiques.

de Cliquez sur l’image pour la version interactive

\[vimeo 658158\]

de musique “Lovely Head” de Goldfrapp

La réalisées avec Proce55ing est réellement impressionnante. On trouve beaucoup d’autres ou sur flickr ou .

s’y est mis aussi et a achevé de me convaincre de regarder Processing de plus près.

Le langage Processing est fortement inspiré de Java, le système de développement est basé sur Java, et on peut exporter les applications sous forme d’applet Java. Pour commencer, on peut se débrouiller sans maitriser cette danse, juste avec des bases de programmation, mais pour faire des choses aussi sophistiquées que les exemples ci-dessus, il faut bien connaitre le graphisme 2D et 3D, voire OpenGL et les maths, mais surtout avoir un talent de graphiste pour que le résultat soit joli.

Ma première application Processing est une version simplifiée et 2D de ma fameuse .

(Mise à jour du 15.1.2011) : Elle était depuis longtemps sur , mais je peux enfin l’intégrer directement à ce blog :

\[processing width="600" height="400" file="/wp-content/uploads/2008/04/Galaxy.jar"\]

Chargement

\[/processing\]

En pressant sur les touches curseur vous pourrez modifier l’ellipsité et la torsion de la galaxie en temps réel. Cette première oeuvre est assez moche, heureusement quelqu’un en a beaucoup amélioré l’esthétique .

Pour vous mettre à Processing vous aussi :

lancez-vous à partir des nombreux exemples fournis
consultez la liste des pour éviter de réinventer la roue et devenir un vrai gourou

Galaxie Spirale et Séquence Principale

Fri, 08 Feb 2008 00:00:00 +0000

Suite à , je m’étais lancé dans la réalisation d’une en temps réel basée sur .

L’idée était principalement d’illustrer le fait que les bras spiraux des galaxies ne tournent pas : se sont des “ondes de pression” dans lesquels la densité d’étoiles est plus élevée qu’ailleurs en raison du fait que les étoiles suivent “en moyenne” des orbites elliptiques décalées, comme illustré sur le graphique ci-contre, où les spirales apparaissent clairement.

Je viens de réaliser une nouvelle version de cette simulation que vous pouvez et exécuter sur votre propre PC (doté d’une carte 3D décente) pour voir 15'000 étoiles tourner devant vos yeux ébahis:

A noter qu’à ma connaissance c’est la seule simulation de Galaxie en temps réel qui révèle les bras spiraux. Ceci est possible car on ne simule pas la physique de la gravitation, mais seulement la géométrie en résultant.

Vie et mort des étoiles

Dans cette nouvelle version , j’ai commencé à implanter un autre phénomène fascinant : le cycle de vie des étoiles. Comme expliqué dans , les étoiles naissent au rythme d’une par jour (!) dans la Voie Lactée, principalement dans les bras spiraux. Puis elles vieillissent et meurent (une par jour aussi !) après n’avoir effectué que quelques tours de la Galaxie. Pour visualiser ceci “à l’échelle” dans ma simulation, j’ai fait le calcul suivant :

ma galaxie contient environ 10^6 x moins d’étoiles qu’une galaxie spirale réelle (je veux un processeur 10'000'000 de fois plus puissant !)
mais elle tourne environ 10^13 x plus vite
donc les étoiles de ma simulation doivent naitre et mourir 10^(13-6) soit 10'000'000 x plus souvent qu’une fois par jour, ce qui fait 116 x par seconde !

La séquence principale

La vie des étoiles se déroule de gauche à droite dans le diagramme ci-dessous:

Les étoiles supergéantes ( ) naissent bleues. Après une vie brève passée à briller 10'000x plus que le Soleil, elles deviennent rouges et meurent brutalement en , brillant comme des millions de soleils pendant quelques heures et laissant une étoile à neutrons, un voire un au centre d’une

Les étoiles naines restent toute leur longue vie bleues/blanches et jaunissent en s’éteignant lentement. 10'000x moins lumineuses que le Soleil, elles deviennent des naines brunes pratiquement invisibles.

La plupart des étoiles, dont le Soleil, suivent la “séquence principale” : elles naissent bleues et lumineuses, et meurent rouges, tout en devenant 1 milliard de fois moins lumineuses qu’au début.

Dans mon programme, je considère pour l’instant que toutes les étoiles suivent la séquence principale. Je simule le vieillissement en regroupant les étoiles en 6 étapes de la séquence. Il y a aussi une étape 0 “nébuleuse” qui correspond au gaz qui forme une étoile jeune et qui résulte de la mort de l’étoile vieille, ce qui permet de définir un cycle. Pour des raisons techniques et pour correspondre à la réalité, le nombre d’étoiles à chaque étape doit rester le même. La simulation permute donc 7 “étoiles” choisies au hasard dans chacune des étapes : une nébuleuse prise au hasard devient une bleue de type O5, une bleue O5 prise au hasard devient BO et ainsi de suite jusqu’à une étoile de type M0 prise au hasard, qui meurt pour donner une nébuleuse.

Ainsi les étoiles vieillissent, mais pas toutes à la même vitesse, ce qui est conforme à la réalité.

Prochaines étapes:

rendre les transitions de couleur plus douces
faire naître les étoiles dans les bras spiraux : c’est là que ça se passe en réalité car les nébuleuses y sont “comprimées”
simuler la trajectoire des étoiles du noyau galactique en 3D. permettre de varier la taille du noyau pour faire des galaxies elliptiques
trouver comment faire des galaxies spirales “barrées”

Références

Cignatures

Tue, 05 Feb 2008 00:00:00 +0000

Tombé par hasard sur qui liste de minuscules programmes en C utilisés comme signatures d’e-mails par des programmeurs fous, ou de génie c’est la même chose. C est un langage de programmation tellement dense qu’il peut en devenir cryptique, ce qui fait qu’il est impossible de deviner ce que font ces programmes sans les lancer. Exemples:

\[code lang="C"\]

main(){char*i=“L0

\[B0BCA7G0BFACIW0BfRAAB0BCACAFR0\[BCAFE0LCCAFR0",j,k=0;for(;\*i; \*++i==48&&puts(""))do for(j=\*i-48>>k&7;j--;)putchar(k+32);while(k^=3);}\[/code\]

fait :

 ###
 ##### ##
 ## ## ## ##
 ## ## ## ## ### ####
 ## ###### #### ## ## ##
 ## ## ## ## ## ## ####
 ##### ## ## ## ## ##
 ### ## ## ## ## ####

Celui-ci fait un jeu de pendu dont la solution est le nom de l’auteur !

\[code lang="C"\]

main(){char s[]=".bg`z`lE)gc`}{hD-|\/OI:retteL>nn”,k;long w=32,r,_,y ,i,b,g,p[]={63l«16,37968,15,32,896,2048,24576,37449,2,12546,3074,19138 ,3586,585,0},t;b=g=r=0;while((b<7)&&(g<65278)){for(_=16;_+10;)putchar(_ –>0?_&7?g»_&1?s

\[\_\]

^9:46:w:s

\[\_+w\]

);while((k=getchar())<65);for(_=15,t= g;_;)if((s

\[\_--\]

^9|w)(k|w))g|=2«_;if(tg)r|=p

\[b++\]

;for(y=9,t=0;y–;) for(_=9;_;)putchar(–_?(i=p

\[y+6\]

»24-3*_&7)?r»t++&1?s

\[i+15\]

:w:w:10);}}

\[/code\]

>Letter:g—- | : | O/ | I | | ——

Martijn .ei.in.

celui-ci

\[code lang="C"\]

int a

\[1817\]

;main(){int z=5,p=5,q=5,r=5; for(p=80;q+p-80;p-=2*a

\[p\]

)for(z=9;z–;)q=3&(r=time(0) +r*57)/7,q=q?q-1?q-2?1-p%79?-1:0:p%79-77?1:0:p<1659?79:0:p>158?-79:0,q?!a

\[p+q\*2 \]

\[p+=a\[p+=q\]

=q]=q:0:0;for(;q++-1817;)printf(q%79?"%c":"%cn","#"

\[!a\[q-1\]

]);}

\[/code\]

fait un labyrinthe dans ce genre :

 ######### ### ### ####### # # ### ### # # # ####### # # ######### ####### ###
 # # # # # # # # # # # # # # # # # # # # # # #
 # ##### ####### ##### # ############# ####### # ####### ########### ####### #
 # # # # # # # # # # # # # # # #
 # # # ### # # # ####### # ##### ### ### # ### ### ### ### ### # ### # # #####
 # # # # # # # # # # # # # # # # # # # # # #
 ####### ##### ### # # ##### # # # ####### ### ##### # # ### ######### ### # #
 # # # # # # # # # # # # # # # #
 ####### # # # ############### ####### # ##### # # # ####### ##### # # # ### #
 # # # # # # # # # # # # # # # # # # #
 ##### ### ##### # ######### ##### # # ####### ### ##### ### # # ### ### ### #
 # # # # # # # # # # # # # # # # # #
 ##### # ####### # ##### # # ##### # ### # # ########### ### ### # ### #######
 # # # # # # # # # # # # # # # # # # # # #
 # # # ####### ### # ### ##### # ##### ### ### ### # ### ### # # ##### # # ###
 # # # # # # # # # # # # # # # # # # # # #
 # ### ### # ##### # # # ### ### ### ### ####### # ####### ### # # ####### # #
 # # # # # # # # # # # # # # # # # #
 ############# ####### # ##### ### ### ######### ##### # # # ##### # ### #####
 # # # # # # # # # # # # # # # # # # # # # # # # # #
 # ##### ##### ### ####### # ##### ##### # # # ##### ### ##### ######### # # #

Une discipline particulière concerne l’ensemble de Mandelbrot :

\[code lang="C"\]

main(){char*c=" _.+=#n)rezneuM drahnreB(xx.xxx@xxx";int x,t,y;float a, b,d;for(y=0;y<25;y++){for(x=0;x<80;x++){t=b=d=0;do{a=b*b-d*d-2.1+.035*x ;d=2*b*d+.088*y-1.1;b=a;t++;}while(t<32&&b*b+d*d<4);putchar(c

\[x>79?6:y> 23&&x<28?34-x:t>31?0:t>>4?5:t>>3?4:t>>2?3:t>>;1?2:1\]

);}}} /*xxx@xxx.xx*/

\[/code\]

donne :

_____________.................................++++++++==+++++++++...............
___________...............................+++++++++++++=#====+++++++............
__________............................++++++++++++++++=== ==+++++++++++.........
_________..........................++++++++++++++++=### #=#=++++++++++........
________........................+++++++++++++++++++== ==+++++++++++......
_______......................+++++++++++++=###=== =### ##=== ==++=#=+++.....
______....................++++++++++++++++==# # = ##+++++...
_____................+++++++++++++++++++===# #==++++++..
____...........+++++++++==+++++=++++++====# #===++++..
____.....++++++++++++++===##===##=======# #=+++++.
____..+++++++++++++++++===# #== #=+++++.
___.+++++++++++++++======# # #=+++++++
___+++++++=+++======= =+++++++++
___+++++++=+++======= =+++++++++
___.+++++++++++++++======# # #=+++++++
____..+++++++++++++++++===# #== #=+++++.
____.....++++++++++++++===##===##=======# #=+++++.
____...........+++++++++==+++++=++++++====# #===++++..
_____................+++++++++++++++++++===# #==++++++..
______....................++++++++++++++++==# # = ##+++++...
_______......................+++++++++++++=###=== =### ##=== ==++=#=+++.....
________........................+++++++++++++++++++== ==+++++++++++......
_________..........................++++++++++++++++=### #=#=++++++++++........
__________............................++++++++++++++++=== ==+++++++++++.........
xxx@xxx.xx(Bernhard Muenzer)..............+++++++++++++=#====+++++++............

on peut même faire plus court :

\[code lang="C"\]

main(){int c;float t,x,y,b=-2,a=b;for(;b-=a>2?.1/(a=-2):0,b<2;putchar(30+ c),a+=.0503)for(x=y=c=0;++c<90&x*x+y*y<4;y=2*x*y+b,x=t)t=x*x-y*y+a;}

\[/code\]

Il y en a encore plein d’autres, mais mon préféré reste cet extraordinaire programme :

\[code lang="C"\]

int a

\[52514\]

,b,c=52514,d,e,f=1e4,g,h;main() {for(;b=c-=14;h=printf("%04d",e+d/f)) for(e=d%=f;g=–b*2;d/=g)d=d*b+f*(h?a

\[b\]

:f/5),a

\[b\]

=d%–g;}

\[/code\]

Que fait-il ? Je vous défie de le deviner.

Une description de l’algorithme utilisé est

Perlisismes : les dictons informatiques d'Alan Perlis

Mon, 21 Jan 2008 00:00:00 +0000

Alan Jay Perlis

En préparant un autre article, je suis tombé sur quelques citations d’ , un précurseur de la programmation et célèbre professeur à Carnegie Mellon et Yale. Les dictons informatiques dont il émaillait ses cours ont été publiés

\[1\]

et sont passés à la postérité sous le nom de “Perlisismes”, mais ne sont disponibles qu’en anglais. Ne les ayant pas trouvé en français, je me suis fendu (de rire) d’une traduction, en les reclassant par thèmes subjectifs et en les classant selon mes préférences. Régalez vous !

Philosophie

La constante d’une personne est la variable d’une autre.
Les inconscients ignorent la complexité. Les pragmatistes en souffrent. Certains parviennent à l’éviter. Les génies la suppriment.
En poursuivant l’inaccessible, la simplicité se trouve en travers du chemin.
La simplicité ne précède pas la complexité, elle la suit.
Vous ne pouvez pas communiquer la complexité, juste en faire prendre conscience.
N’ayez pas de bonnes idées si vous n’êtes pas prêt à en être responsable.
L’optimisation entrave l’évolution.
Souvent les moyens justifient la fin : le but fait avancer la technique, et la technique survit même quand le but s’effondre.
On ne peut pas aller de l’informel au formel par des moyens formels.
Slogan pour un labo de recherche : Nous travaillons aujourd’hui sur ce à quoi d’autres vont penser demain (What we work on today, others will first think of tomorrow.)

Informatique

Dans la symbiose homme-machine, c’est l’homme qui doit s’adapter parce que la machine ne peut pas.
En informatique, les invariants sont éphémères.
La preuve de la valeur d’un système informatique est son existence.
Le contact prolongé avec les ordinateurs transforme les mathématiciens en comptables et vice versa.
L’informatique (Computer Science) est gênée par les ordinateurs.
L’ordinateur est le pollueur ultime : ses fèces sont indistinguables de la nourriture qu’il produit.
Les systèmes ont des sous-systèmes, et les sous-systèmes ont des sous-sous-systèmes et ainsi de suite à l’infini. C’est la raison pour laquelle nous recommençons chaque fois de zéro.

Intelligence artificielle

Une année de travail sur l’intelligence artificielle est suffisante pour vous faire croire en Dieu.
Dans un ordinateur, le langage naturel n’est pas naturel.
Si votre ordinateur parle anglais, il a probablement été fabriqué au Japon.
Quand nous écrivons des programmes qui “apprennent”, ce qui arrive c’est que nous apprenons, et eux pas.
Il y aura toujours des choses que nous aimerions dire dans nos programmes, mais qui ne peuvent être que mal dites avec tous les langages connus.
La seule théorie constructive liant les neurosciences et la psychologie surviendra de l’étude du logiciel.
Le but de l’informatique est l’émulation de nos facultés de synthèse, pas la compréhension des facultés analytiques.
L’ordinateur le plus important est celui qui bouillonne dans nos crânes et recherche de nouvelles satisfactions extérieures. La standardisation des ordinateurs serait un désastre, donc ça n’arrivera probablement pas.

Programmation

Il y a deux manières d’écrire des programmes sans erreurs. Seule la troisième marche.
Le 11ème commandement était “Tu programmeras” ou “Tu ne programmeras pas”, je ne me souviens plus au juste.
Programmer est un acte contre nature.
Tout programme a (au moins) deux buts : celui pour lequel il a été écrit, et celui pour lequel il ne l’a pas été.
Il est plus facile de changer la spécification pour qu’elle corresponde au programme que le contraire.
Adapter de vieux programmes à de nouvelles machines signifie habituellement adapter les nouvelles machines pour qu’elles se comportent comme les anciennes.
En informatique, passer de l’évident à l’utile est une définition vivante du mot “frustration”.
La documentation est comme une assurance-vie : le bénéficiaire n’est presque jamais celui qui l’a signée.
On ne manquera jamais de choses à programmer aussi longtemps qu’il y aura un seul programme.
le meilleur livre grand public sur la programmation est “Alice au Pays des Merveilles”, parce que c’est le meilleur livre grand public sur tous les sujets.

Code

Chaque programme est un bout d’un autre programme qui convenait mal.
Tout doit être construit de haut en bas (top-down), sauf la première fois.
Si vous avez une fonction avec 10 paramètres, vous en avez probablement oublié.
Un programme sans boucle et sans structure de donnée ne vaut pas la peine d’être écrit.
Rendre quelque chose variable est facile. Le problème, c’est de contrôler la durée de la constance.
A long terme, tout programme devient , puis des gravats.
La récursion est la racine du calcul car elle échange la description contre du temps.
Un programme qui manipule un grand nombre de données le fait d’un petit nombre de manières.
C’est mieux d’avoir 100 fonctions travaillant sur une structure de données que 10 fonctions pour 10 structures.

Programmeurs

Une fois que vous comprenez comment écrire un programme, trouvez quelqu’un d’autre pour l’écrire.
Pour comprendre un programme, vous devez devenir à la fois la machine et le programme.
Il est plus facile d’écrire un programme incorrect que d’en comprendre un correct.
Si votre interlocuteur hoche la tête pendant que vous lui expliquez votre programme, réveillez-le!
Quand deux programmeurs se rencontrent pour critiquer leurs programmes, les deux sont silencieux.
Peut-être que si nous écrivions des programmes depuis notre enfance, nous pourrions les lire à l’age adulte.
En programmation, tout ce que nous faisons est un cas particulier de quelque chose de plus général, et souvent nous nous en apercevons très vite.
Vous pouvez mesurer les perspectives d’avenir d’un programmeur par son attitude par rapport à la vitalité de FORTRAN.
Il ne faut pas évaluer les programmeurs par leur ingéniosité ou leur logique, mais par l’étendue (completeness) de leur étude de cas (case analysis).

Langages

Il ne vaut pas la peine de connaitre un langage qui ne modifie pas votre façon de penser la programmation.
Certains langages de programmation arrivent à absorber des changements, mais résistent au progrès.
Sur une période de 5 ans on trouve un superbe langage de programmation. Mais on ne sait pas quand cette période de 5 ans aura lieu.
Un langage de programmation est “bas niveau” quand il nécessite de faire attention à ce qui n’a aucune importance.
Un bon système ne peut pas avoir un langage de commande faible.
Si quelqu’un dit “je veux un langage de programmation dans lequel je n’aurais qu’à dire ce qui doit être fait”, donnez lui une sucette.
Alors que les chinois devraient adorer , ils investissent dans FORTRAN.
Un programmeur LISP connait la valeur de tout, mais le cout (cost) de rien.
Au cours des siècles, les Indiens ont développé un langage de signes pour communiquer des phénomènes intéressants. les programmeurs des différentes tribus (FORTRAN, LISP, ALGOL, SNOBOL, etc.) auraient pu en utiliser un pour éviter de transporter un tableau noir sur leur poneys.

Bons conseils:

la symétrie est un concept réduisant la complexité : utilisez la partout.
Entrez tôt dans une routine : faites la même chose de la même façon. Accumulez les tournures (idioms). Standardisez. la seule différence (!) entre Shakespeare et vous est la liste de ses tournures, pas la taille de son vocabulaire.

Enseignement

Enseigner la programmation va à l’encontre de l’éducation moderne : Quel est le plaisir à planifier, se discipliner à organiser ses pensées, faire attention aux détails et apprendre à être autocritique ?
On n’apprend pas l’informatique avec une calculatrice de poche, mais on peut oublier l’arithmétique.
La plupart des gens trouvent le concept de la programmation évident, mais la réalisation impossible.
Tout le monde peut apprendre à sculpter : on aurait du dire à comment ne pas le faire. C’est la même chose avec les grands programmeurs. (édité le 23.11.11 à partir de WikiQuote)
Vous croyez savoir quand vous apprenez, vous en êtes sur quand vous écrivez, persuadé quand vous enseignez, mais certain seulement quand vous programmez.

Jeux de mots intraduisibles

Syntactic sugar causes cancer of the semicolon. (Le cause le cancer du point-virgule)
Editing is a rewording activity. (L’édition est une activité de rephrasage (rewOrding) récompensante (rewArding))
Like punning, programming is a play on words.
In software systems, it is often the early bird that makes the worm.

Vous trouverez encore sur que je n’ai pas traduits, soit parce que je ne les trouvais pas terribles, soit parce que je ne les ai pas compris …

Référence :

\[altmetric doi="10.1145/947955.1083808" float="right"\]Alan J. Perlis “ ”, SIGPLAN Notices Vol. 17, No. 9, September 1982, pages 7 - 13

Bugman blogifié

Sat, 12 Jan 2008 00:00:00 +0000

Depuis longtemps je suis un fan du , un incroyable ramassis de choses épatantes sur des sujets comme la physique, les maths, les fractales et les papillons, le tout illustré par de magnifiques images et animations faites avec et principalement.

Le seul problème est que ce site était devenu affreusement lourd, à la fois graphiquement et par la taille des énormes pages sur lesquelles on frisait l’indigestion à la première visite et on ne retrouvait plus rien à la seconde…

Je me suis donc mis à “forcer la main” de Paul en lui créant un qui lui a beaucoup plu, et sur lequel je vais l’aider à migrer tout son passionnant contenu.

Abonnez-vous à pour suivre toutes les choses merveilleuses qui vont être (re) publiées sur le blog deBugman, vous ne le regretterez pas !

Quelques exemples accessibles via les jolis gif animés ci dessous :

La montée en puissance des GPUs

Fri, 02 Nov 2007 00:00:00 +0000

Dans les ordinateurs vendus depuis 2003 environ, le microprocesseur (CPU) fourni par Intel ou AMD n’est plus le composant le plus puissant, et souvent plus le plus couteux non plus. Désormais c’est le GPU, le Graphics Processing Unit, qui détermine largement la puissance d’un PC. Strictement limités au graphisme il y a peu, ces processeurs sont désormais capables d’effectuer certains calculs nettement plus vite que les processeurs classiques. Actuellement, la puissance de calcul du G80 de nVidia est 5 à 6 fois supérieure à celle du Core 2 Duo d’Intel, voire plus (1, 2).

puissance de calcul des GPU et CPU ( )

Conséquence immédiate :

Si vous achetez un ordinateur pour y faire fonctionner les applications les plus exigeantes, c’est-à-dire les jeux vidéo, il faut faire plus attention au choix du GPU qu’au CPU. Vous ne gagnerez que quelques pourcents de performance avec un CPU plus rapide qui vous coûtera quelques centaines de francs, alors que la même somme investie dans une carte graphique basée sur un GPU plus récent ou puissant peut doubler le nombre d’images / seconde (fps) de vos applications favorites.

Un peu d’architecture des processeurs

Cette situation est la conséquence de cahiers des charges différents assignés aux deux composants:

le CPU est “généraliste” : il doit être capable d’exécuter plusieurs programmes différents quasi simultanément, de réagir aux actions de l’utilisateur et de gérer les nombreux périphériques de l’ordinateur, fonctionnant à des vitesses différentes
le GPU est historiquement spécialisé : sa tâche est de produire des images à une cadence régulière, ce qu’il peut faire en exécutant le même programme simple sur des données différentes, correspondant par exemple à des objets 3D distincts ou à des portions distinctes de l’écran.

Ceci a conduit à des architectures différentes pour les deux types de processeurs :

les CPU comportent aujourd’hui 2 ou 4 “coeurs” complexes accédant aux données à travers une grande mémoire cache, le tout synchronisé par une importante logique de contrôle
Sur la même surface de silicium, un GPU moderne contient jusqu’à 128 unités de calcul simples, mais très peu de mémoire cache et de logique de contrôle.

architecture des GPU et CPU ( )

Cette différence d’architecture fait qu’il n’est pas possible d’exécuter sur le GPU un programme “classique”, écrit pour le CPU car:

les unités de calcul (ALU) du GPU sont individuellement moins puissantes qu’un coeur de CPU.
Un GPU est un processeur SIMD, ou “Single Instruction Multiple Data” : toutes les ALU d’un GPU doivent exécuter le même programme en même temps, alors que chaque coeur de CPU peut exécuter des programmes distincts de façon asynchrone (MIMD)
les échanges de données entre les ALU de GPU sont beaucoup plus limités qu’entre des coeurs de CPU
la structure “pipeline” des GPU fait que leurs performances sonttrès dégradées dès qu’il y a des tests dans le programme. Il faut programmer les GPU sans “if … then .. " !

La principale conséquence de ces différences hardware est que les langages de programmation usuels ne sont pas adaptés à la programmation des GPU. Des langages spécifiques ont été définis, initialement pour la programmation des “shaders”, programmes réalisant tous les effets graphiques des cartes modernes. Mais ces langages permettent aussi la “programmation générale des GPU” (ou ), dont j’ai déjà parlé , , et :

nVidia a défini le langage comme “C pour graphiques”
ATI a plutôt soutenu le standard défini par le standard
Microsoft a encore une fois grandement contribué aux progrès de l’humanité en dotant son système maison Direct3D d’un langage de shader dont l’innovation essentielle consiste à changer une lettre au standard . C’est HLSL. (Non, pas de lien pour eux, z’avez qu’à chercher.)
nVidia a par contre fait un réel pas en avant en proposant son système qui permet de développer directement ses GPU haut de gamme en C “classique” , à l’aide de librairies spécifiques.

Perspectives

Du point de vue matériel, les processeurs du futur combineront sans doute les avantages respectifs des GPU et des CPU. Voici la stratégie probable des principaux acteurs du marché :

Après le rachat d’ATI, AMD a tout en main pour combiner les deux types de processeurs de façon optimale
intel, dont les GPUs ont des performances lamentables, essaie de multiplier le nombre de coeurs de ses CPU tout en s’inspirant de certaines techniques des GPU
nVidia va logiquement tenter de généraliser ses GPU pour leur permettre d’exécuter du code de CPU
On l’oublie souvent, mais le processeur d’IBM développé en collaboration avec Toshiba et Sony pour la Playstation 3 est probablement le précurseur de cette nouvelle génération de processeurs.

Du point de vue logiciel, deux tendances s’affrontent:

la définition de langages spécifiques comme GLSL, ou prenant en compte explicitement le parallélisme à la manière des librairies de multithreading existantes
le développement de compilateurs capables de générer du code GPU optimisé à partir de sources en langages classiques, à la manière de CUDA

Il est probable que dans un premier temps les langages comme GLSL jouent le rôle d’ “assembleur des GPU” utilisé pour la création de librairies, que des applications en C utiliseront de manière transparente.

Sources:

Damien Triolet “ ”, BeHardware, March 21, 2007
Jean Etienne, “ ”, Futura-Sciences, 31 octobre 2007

La bonne manière de calculer des trucs

Thu, 11 Oct 2007 00:00:00 +0000

est une page pour informaticiens dans mon genre : elle contient des petits “snippets” de code utile pour contourner certains pièges tendus par les maths et la géométrie.

Par exemple, si on veut calculer sin(x)/x, il faut faire attention à ce qui se passe pour x=0, sinon on obtiendra une erreur de “division by zero” au lieu du résultat attendu, qui est 1. Un bon programmeur prévoira le coup en écrivant (en C++) :

\[sourcecode lang="cpp"\]

if (x == 0.) return 1. else return sin(x)/x;

\[/sourcecode\]

mais ce n’est peut-être pas suffisant. Si x est très petit, la division de deux nombres très petits approximés par nos chers ordinateurs a des chances d’être assez fausse. Pour des raisons expliquées en détail sur la page, il faut s’assurer en fait que x2 est encore un nombre numériquement assez grand par rapport à 1, donc un très bon programmeur écrira ceci :

\[sourcecode lang="cpp"\]

if (1. + x*x == 1.) return 1. else return sin(x)/x;

\[/sourcecode\]

ce qui parait mathématiquement absurde puisqu’on imagine pas que 1+x2 puisse valoir 1 pour x≠0. Mais informatiquement, c’est très possible.

L’article donne ainsi une série de recettes pour calculer des expressions dangereuses, par exemple :

1-cos(x) → 2*sin(x/2)2
acos(1-x) → 2*asin(sqrt(x/2))
et bien d’autres

Mais les recettes les plus intéressantes (en tout cas pour moi) concernent la géométrie.

Pour calculer l’angle entre 2 vecteurs u et v, l’ “approche pachyderme” comme disait Burgi consiste à évaluer acos(dot(u,v)), dot étant la fonction renvoyant le produit scalaire des 2 vecteurs. mais si u ou v ne sont pas parfaitement normalisés et que dot renvoie un résultat un pouillème plus grand que 1 : crash.

une deuxième approche est: 2*atan2(abs(u-v),abs(u+v)). Pas mal mais couteux en temps de calcul. La meilleure implémentation est

\[sourcecode lang="cpp"\]

if (dot(u,v) < 0.) return M_PI - 2*asin(abs(-v-u)/2) else return 2*asin(abs(v,u)/2);

\[/sourcecode\]

La partie vraiment intéressante concerne l’ . (Comme c’est assez spécifique à la 3D, je publie aussi ce qui suit )

L’orientation d’un corps dans l’espace à 3 dimension est défini par 3 angles tout comme la position d’un objet posé sur une sphère est définie par les 2 angles de latitude et de longitude, plus un angle définissant l’orientation de l’objet

Le problème consistant à faire tourner “en douceur” un objet dans l’espace pour l’amener dans une orientation déterminée est appelé “interpolation sphérique linéaire” parce qu’il est équivalent à celui consistant à se déplacer “en douceur” sur une sphère pour atteindre une position et une orientation donnée. Le problème n’est pas trivial pour 2 raisons:

comme les angles sont définis “modulo 360°”, il faut que l’interpolation en tienne compte : si on va par exemple de la longitude -179° à la longitude +179°, il faut faire 2° dans le sens négatif et pas 358° dans le sens positif.
quelle que soit la manière dont on définit les 3 angles, il existe des “singularités” aux point analogues aux pôles : à la lattitude 90°, la longitude n’a plus d’importance mais si on passe par le pôle, il faut “se rappeler” de notre dernière longitude pour pouvoir continuer “tout droit” dans la longitude augmentée de 180° (modulo 360°), et simultanément éviter qu’une mauvaise description de l’angle d’orientation nous fasse faire brusquement un demi-tout sur nous mêmes en passant par le pôle pour conserver un angle par rapport au nord …

“ ” décrit la fonction “slerp” qui définit l’interpolation sphérique linéaire entre 2 vecteurs unitaires v0, v1 ainsi:

sin((1-t)*a) sin(t*a) slerp(v0,v1,t) = ______________*v0 + __________*v1 sin(a) sin(a)

où a est l’angle entre v0 et v1 calculé comme indiqué plus haut. Mais il est clair que pour des angles tels que sin(a) est nul ou très petit, des problèmes numériques vont survenir. En travaillant un peu la fonction slerp peut s’écrire:

sin_over_x((1-t)*a) sin_over_x(t*a) slerp(v0,v1,t) = ____________________*(1-t)*v0 + ________________*t*v1 sin_over_x(a) sin_over_x(a)

où sin_over_x est la fonction sin(x)/x calculée de façon robuste, toujours comme indiqué plus haut

Reste à traiter le cas ou a est proche de 180°, ce qui revient à retourner un objet, ou à aller aux antipodes du point où on se trouve sur le globe. Il y a alors une infinité de trajets possibles, et il faut bien en choisir un plutôt que de laisser l’ordinateur se planter…

Références:

Ken Shoemake, Animating rotation with quaternion curves, SIGGraph ‘85 proceeding

Lua, le nouveau Basic

Fri, 21 Sep 2007 00:00:00 +0000

Me suis mis à programmer un peu en , un “langage de script” , mais aussi par Hyperion.

LUA présente plusieurs caractéristiques étonnantes:

il est très rapide, presque autant que JAVA mais environ 6x plus que Python ou 15x plus que PHP (voir par exemple)
l’interpréteur LUA est très petit : moins de 100k, contre 800k pour Python et beaucoup plus pour les autres langages.
LUA est à la fois un langage très simple, genre “Basic des années 80’”, et offre des notions beaucoup plus avancées décrites plus bas
LUA est le premier langage de programmation brazilio-catholique : il a été créé à la et est donc mieux documenté en portugais qu’en français.

Outils

Télécharger LUA depuis le site ne sert à rien, à moins que vous aimiez programmer dans une fenêtre DOS…

Le mieux est de vous initier à LUA avec un petit IDE simple mais avec ce qu’il faut pour éditer, compiler et déboguer du code LUA. Comme l’interpréteur LUA est tout petit, il est fourni avec !

J’ai investigué d’autres environnements de développement LUA, y compris certains censés s’intégrer au Microsoft Visual Studio, mais aucun n’a fonctionné correctement :-(

Un langage (très) simple

En LUA comme avec beaucoup de langages de script, les variables peuvent prendre n’importe quel type sans déclaration préalable : a=1 -- un nombre entier a=3.14 -- un nombre réel a="hello" -- une chaine
comme Pascal, LUA veut qu’on ferme les blocs avec end: function chose(x) if x<10 then return x+10 else return x end end while not quelque do for i=debut,fin do quelque=chose(i) end end
voilà, vous savez tout ce qu’il faut pour programmer en LUA ;-). En fait, toutes les fonctions de LUA permettant de faire des choses utiles proviennent de comme math, os et string, ou d’extensions programmées en C comme celles développées dans le cadre du .

Subtilités

Les variables non initialisées valent “nil”. On peut tester si une variable vaut nil.
On peut appeler une fonction avec moins de paramètres qu’elle n’en accepte. Les paramètres surnuméraires servent donc de paramètres optionnels et prennent la valeur nil, donc on peut leur affecter une valeur par défaut…
Les fonctions peuvent être référencées par des variables: function sinus(x) return math.sin(x) end function tabule(f,de,a,pas) -- le paramètre f est une fonction ! for i=de,a,pas do print(i,f(i)) end end tabule(sinus,0,2*math.pi,0.1) -- la fonction est passée en paramètre
Les “tables” de LUA sont bien plus sophistiquées que des tableaux ou vecteurs car on peut y combiner des types différents, y compris des fonctions, mettre des tables dans des tables, assigner les indices etc. ce qui permet de créer de puissantes structures de données : a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
Les sont des tables contenant des références aux fonctions appelées lorsqu’on manipule une variable, que l’on peut “attacher” à celle ci. La variable devient donc un “objet” même si LUA n’est pas un langage “orienté objet” stricto-sensu (très belle “phrase à la con” lue dans Joystick : j’aime bien “stricto-sensu”: ça fait karatéka !).
Avec ce mécanisme, on peut même redéfinir les opérateurs d’addition, de multiplication etc comme avec C++ ! En fait, LUA peut servir aux néophytes que vous êtes à comprendre comment marche la programmation objet. Pour cela, lire dans l’ordre les 3 tutoriels puis et enfin
LUA est en principe multithread grâce au support de coroutines, mais je n’ai pas encore expérimenté ces fonctionnalités…

Pièges

LUA est rapide parce qu’il ne vérifie rien, même pas qu’une variable existe (il n’y a pas de “option explicit” comme dans Visual Basic…). Il faut donc être très prudent et utiliser le debug de LuaEdit intensivement: somme=2+2 print(somne) -- génère une erreur
les variables de type “table” sont toujours des références aux tables, et en raison de la complexité potentielle des tables, il n’y a pas de fonction prédéfinie pour copier une table. Donc: a = { "x", "y"} b=a -- crée une 2ème référence à la table print(b[1]) -- affiche "x" b[1]="modifié!" -- change aussi a[1] !!! print(a[1]) -- affiche "modifié!"

Conclusion

rapide, léger et puissant, LUA est un langage idéal pour être embarqué dans d’autres applications, comme les jeux ou Hyperion.
Il est moins adapté pour réaliser des applications qui en pilotent d’autres. Python, beaucoup plus riche en librairies sophistiquées et plus robuste au niveau du traitement des exceptions et erreurs semble mieux armé dans ce cas (voir qui compare avantages/inconvénients de ces 2 langages)

Simulation de Galaxie Spirale

Thu, 23 Aug 2007 00:00:00 +0000

Poursuivant ma découverte (*) du génial Hyperion 3D, je me suis attaqué à simuler une Galaxie Spirale.

Il faut dire que la formation des bras spiraux des galaxies n’a été comprise que récemment parce qu’il fallait « penser différemment ». Bien que je l’aie un peu expliqué , je voulais le voir pour le croire. Et voilà, c’est fait, admirez !

Si vous voulez vous aussi explorer de belles galaxies virtuelles en temps réel, il vous faut:

et l’installer
télécharger , et le décompresser n’importe où
lancer Hyperion et ouvrir SpiralGalaxy.xml .
Jouer avec les touches F1-F2 et F3-F4 qui modifient les paramètres eratio et etwist (voir plus bas) pour obtenir différentes spirales.

Comme le montre l’image ci-contre (réalisée avec une petite macro SolidWorks, en passant…) les bras spiraux sont simplement un effet géométrique : ils correspondent à la zone dans laquelle les ellipses sont rapprochées, donc il y a une plus grande densité d’étoiles dans ces zones, mais les étoiles suivent tout de même des orbites elliptiques : elles ne restent pas dans les bras.

La simulation fait décrire à quelques milliers d’étoile des trajectoires elliptiques autour du centre de la galaxie, le grand et le petit axe de chaque trajectoire étant tournés d’un angle qui dépend de la distance moyenne au centre. Il faut donc calculer la trajectoire de chacune des milliers d’étoiles en temps réel, chose possible avec Hyperion grâce à son intégration du langage LUA, que je ne connaissais pas du tout. C’était donc l’occasion de l’apprendre. Il a beaucoup de qualités dont je reparlerai ailleurs, et un gros défaut : faiblement typé, il n’effectue que peu de vérifications à la compilation et aucune à l’exécution : en cas d’erreur, c’est le crash.

La programmation ne pose aucune difficulté particulière pour quelqu’un connaissant un peu la trigo et la 2D. Oui, 2D parce que tous les calculs se font dans le plan XY, la coordonnée Z de chaque étoile étant un petit nombre aléatoire constant, destiné à donner un peu d’épaisseur à la Galaxie.

La visibilité des bras dépend:

de deux paramètres définissant:
1. l’aplatissement des ellipses (eratio = grand axe / petit axe)
2. l’angle de rotation des ellipses en fonction du rayon (etwist)
de l’apparence des étoiles. Les premiers bras bien visibles ont été obtenus avec des étoiles texturées avec un gros point rouge. En utilisant une texture d’étoile réaliste trouvée la couleur est plus crédible, mais les bras sont moins visibles :

l’idéal serait d’utiliser plusieurs vertex pool avec plusieurs textures différentes pour simuler différents types d’étoiles, avec leurs couleurs.

(article aussi publié )

GPUs et Physique

Sat, 19 May 2007 00:00:00 +0000

Dans votre ordinateur, il y a un CPU (Central Processing Unit) de chez Intel ou AMD communément appelé “processeur”, et un GPU (Graphics Processing Unit) de chez nVidia ou ATI. Il n’y a pas si longtemps, le GPU était un circuit “fermé”, non programmable par le commun des mortels, entièrement dédié à la production de belles images sur votre écran. Depuis quelques années, ces circuits sont devenus programmables pour permettre de produire de très beaux effets graphiques, et leur puissance à augmenté, augmenté… A tel point qu’aujourd’hui, votre GPU contient probablement plus de transistors que votre CPU, et est certainement capable de résoudre certains problèmes plus rapidement !

Alors qu’un CPU a maintenant 2 coeurs capables d’exécuter chacun quelques dizaines de tâches complexes en (quasi-) parallèle, un GPU peut exécuter un petit programme appelé “shader” pour chaque point de l’écran (presque) en même temps, soit traiter des milliers de données (presque) simultanément. Pour autant qu’un problème puisse être ramené à celui de petits points “intelligents” qui ne parlent et écoutent que leurs voisins immédiats, le GPU va le résoudre bien plus vite que le CPU.

Quelques exemples:

la , déjà mentionné dans l’article sur , mais on reste dans le monde de l’inutile beauté des mathématiques.
, déjà mentionné qui combine la fonction principale d’une carte graphique, représenter une scène en 3D, avec des calculs relativistes nécessitant 4 dimensions grâce au fait que les GPU traitent 4 composantes de couleur RGBA (Rouge, Gert, Bleu, trAnspArent)
Et là je viens de tomber sur plusieurs références expliquant comment simuler la gravitation entre N corps avec un GPU, ce qui permet de simuler une mini galaxie de 8192 étoiles beaucoup plus vite qu’avec un CPU:
- Mark Harris “Mapping Computational Concepts to GPUs”, nVidia ( )
- Francisco Chinchilla, Todd Gamblin, Morten Sommervoll “Parallel N-Body Simulation using GPUs ( )
- L. Nyland, M. Harris, and J. Prins, “N-body simulations on a GPU,” in Proc of the ACM Workshop on General-Purpose Computation on Graphics Processors, 2004.
- Tsuyoshi Hamada, Toshiaki Iitaka, “The Chamomile Scheme: An Optimized Algorithm for N-body simulations on Programmable Graphics Processing Units” , 2007 ( )

Pour rester au courant sur ce sujet, suivre le site de référence (General-Purpose Computation Using Graphics Hardware)

Tout ceci et la récente fusion d’AMD (CPU) et d’ATI (GPU) fait penser que les prochains processeurs combineront peut-être les avantages respectifs des CPU et des GPU. Peut-être en coupant la poire en deux en faisant beaucoup de coeurs simples, comme dans le “Cell” d’IBM qui trône dans les PlayStation 3 ? Il faudra encore apprendre à programmer ce genre de puces pour en tirer toute la puissance…

Relativistic Computer Game

Wed, 02 May 2007 00:00:00 +0000

Relativity was discovered in 1905 by Albert Einstein and describes a world full of surpises and strange effects

\[1\]

which have not been exploited in movies or computer games so far.

Graphically, simulating fast moving spaceships or simply a world where light moves much slower than 300'000 km/s generates interesting visual effects:

objects are deformed as in picture+movie below, which makes them harder to identify quickly
their color is altered, enabling to visualize their speed
the field of vision becomes restricted to the direction of displacement

Those effects can be viewed in “ ”

\[1\]

, a PC software that lets you navigate in a scenery at relativistc speed.Even more interstingly, the “lag” induced by communication delays is a general problem that limits the geographic distance between players of a network game, but relativistic games might be designed to take advantage of the lag, and even make it artifically longer to make the game more interesting. Such games would rely on the player’s ability to anticipate possible actions from other players rather than reacting to them.

Technically, relativistic visual effects can be computed in real time by modified “3D engines”, while lag handling requires only memory buffers.

All you need now to create a very original video game based on relativity is a good gameplay…

References:

Craig M. Savage, Antony C. Searle, Lachlan McCalman, “ ”. Department of Physics, Faculty of Science, The Australian National University. Interactive Program for PC using can be downloaded
with
A.C. Searle, C.M. Savage, P.A. Altin, F.H. Bennet and M.R. Hush, Through Einstein’s Eyes, The Physicist, July/August 2005. ArXiv: physics/0508224. , ,
C.M. Savage and A.C. Searle, , The Physicist, July/August 1999
D. Weiskopf, “ ”, Ph.D. thesis, U. Tübingen (2001).
M. Bochers, “ ”, Ph.D. thesis, U. Tübingen (2005).
U. Kraus, “ ”: Featured on the cover of Physics Today 58, num. 1, Jan 2005.
, 2004, short novel (in french) describing a travel at relativistic speed to Barnard star

DicoLib

Wed, 14 Sep 2005 00:00:00 +0000

DicoLib est une librairie C++/STL pour les jeux de mots, que j’ai développé initialement pour résoudre le casse-tête “ ”

Complexité

L’algorithme “force brute” pour résoudre “ ” consiste à chercher les n mots de 8 lettres du dictionnaire (O(N)), puis pour chacun d’eux, enlever successivement chaque lettre et vérifier s’il est présent dans le dictionnaire (O(N.log N) pour liste triée), et recommencer s’il y est. La complexité est environ O(N+n.100.N.log N). Le facteur 100 est une estimation du nombre de recherches dans le dictionnaire pour chaque mot avant d’arriver à une impasse. Avec typiquement N=30’000 et n=5’000, on se retrouve avec ‘240 milliards de comparaisons’ de chaînes de caractères à effectuer si l’on veut trouver toutes les solutions. Compter une petite heure…

On pourrait se satisfaire de ceci et se demander pourquoi passer des heures à programmer une solution plus futée. Et bien, si on est capable de retrouver rapidement les mots qui ne se distinguent d’un autre que par une seule lettre, ou deux ou trois, on obtient un correcteur d’orthographe rapide et efficace. Mais pour une telle application, la complexité mentionnée ci-dessus serait inacceptable.

Conception

Comment accélérer très sérieusement la recherche de mots “semblables” a un autre dans un dictionnaire ?

Quelques idées :

grouper les mots par tailles. Si on cherche un mot de 6 lettres, on ne le cherchera que parmi ceux-là.
construire une “signature” du mot sous la forme d’un ensemble de 26 bits indiquant quelles lettres sont présentes dans le mot, et grouper les mots ayant la même signature (donc composés des mêmes lettres) dans une liste. 26 bits, c’est moins que 32, donc très pratique à manipuler par le processeur pour des opérations logiques. Mais c’est trop pour être utilisé comme clé dans une table de hachage, qui aurait dans les 64 millions d’entrées.

Je me suis dont mis à réfléchir à une structure de donnée permettant de stocker un dictionnaire de mots sous une forme permettant la recherche rapide de mots similaires (avec une lettre en plus ou en moins), des anagrammes (mots obtenus par permutation des lettres) ou selon les lettres qui les composent (pour le scrabble).

J’ai alors eu une idée simple, dont je ne sais pas encore si elle est originale, mais en tout cas elle est très efficace, et j’ai écrit un ensemble de classes C++ “Dico.lib”,une librairie permettant de réaliser en quelques lignes des programmes de résolution de divers jeux de lettres.

L’idée principale de DicoLib est de stocker les mots dans une structure permettant d’y accéder rapidement sur la base de 2 informations simples :

la longueur du mot
une clé de 26 bits (letterset) codant la présence de chaque lettre de l’alphabet dans le mot. par exemple le mot “alphabet” donne

11001001000100000001000000
abcdefghijklmnopqrstuvwxyz

Structure de données

dico.lib définit la hiérarchie de classes suivantes :

class Word // mots du dictionnaire
class letterset : public std ::bitset<26> // clé d’accès
class WordList : public std ::list // liste de mots
class Anagrams : public WordList // liste d’anagrammes
class AnagramsList : public list // liste de listes d’anagrammes
class SameLetters : public vector // mots formés des même lettres, organiséss par longueurr
class Dico : public std ::map // dictionnaire utilisant les letterset comme clé primaire

Liens

, d’où vous pouvez télécharger le code et contribuer à le développer
, article sur
des dictionnaire en mode texte sont disponibles ici:

Pentominos

Sun, 04 Sep 2005 00:00:00 +0000

J’avais écrit un programme “PentoSolver” en Visual Basic qui trouve les solutions 6x10 mais résout toutes les variantes de Pentominos et de Polynominos encore plus vite, directement sur votre explorateur… TRES FORT !

SuperShape Exporer : a first experience with DevLib

Thu, 05 Aug 2004 00:00:00 +0000

SuperShape Explorer has 2 goals:

explore 3D shapes generated by the
see what can be done with the

SuperShape runs on Windows XP with OpenGL. You’ll need Visual C++ 7.1 (2003) to recompile it. SuperShape is freeware, comes with open source code (you need DevLib) and without any warranty….

Usage

After installation, program will start automatically. You can then:

rotate the shape by moving your mouse around while pressing any mouse button
press (Space) to generate a random SuperShape
press (C) for a cube, (Y) for a cone, (X) for a cylinder, (S) for a sphere, (D) for a diamond
press (0,1,2..9) keys to set the M1 value accordingly
press (W) for Wireframe, (V) for volume again
(ESC) to escape

Known Problems:

Uses 100% of processor since supershape is recomputed at every frame
Face culling is sometimes wrong (you can sometimes see faces that should be hidden. Probably because normals aren’t computed yet…

Todo list:

Remove that ugly perspective effect
Solve the face culling problem
Avoid recomputing the shape if it doesn’t change
Do smooth transitions (“morphing”) when changing shapes
Automatically adjust the mesh density to keep fps constant (probably using the )
Add a way to move the camera and to zoom in/out with mouse
Add lights
Add GUI widgets to allow editing the supershape like the tool

History: 2004/8/5

V 1.0 done from existing DevLib demo code

15000 décimales de Pi en 133 octets de C

Mon, 28 Jun 2004 00:00:00 +0000

Voici un minuscule programme en langage C de 133 caractères, c’est vraiment pas gros….

\[c\]

int a

\[52514\]

,b,c=52514,d,e,f=1e4,g,h;main() {for(;b=c-=14;h=printf("%04d",e+d/f)) for(e=d%=f;g=–b*2;d/=g) d=d*b+f*(h?a

\[b\]

:f/5),a

\[b\]

=d%–g;}

\[/c\]

Si vous l’exécutez. vous allez obtenir ce résultat en quelques secondes:

31415926535897932384626433832795028841971693993751 05820974944592307816406286208998628034825342117067 98214808651328230664709384460955058223172535940812 84811174502841027019385211055596446229489549303819 64428810975665933446128475648233786783165271201909 14564856692346034861045432664821339360726024914127 37245870066063155881748815209209628292540917153643 67892590360011330530548820466521384146951941511609 43305727036575959195309218611738193261179310511854 80744623799627495673518857527248912279381830119491 29833673362440656643086021394946395224737190702179 86094370277053921717629317675238467481846766940513 20005681271452635608277857713427577896091736371787 21468440901224953430146549585371050792279689258923 54201995611212902196086403441815981362977477130996 05187072113499999983729780499510597317328160963185 95024459455346908302642522308253344685035261931188 17101000313783875288658753320838142061717766914730 35982534904287554687311595628638823537875937519577 81857780532171226806613001927876611195909216420198 93809525720106548586327886593615338182796823030195 20353018529689957736225994138912497217752834791315 15574857242454150695950829533116861727855889075098 38175463746493931925506040092770167113900984882401 28583616035637076601047101819429555961989467678374 49448255379774726847104047534646208046684259069491 29331367702898915210475216205696602405803815019351 12533824300355876402474964732639141992726042699227 96782354781636009341721641219924586315030286182974 55570674983850549458858692699569092721079750930295 53211653449872027559602364806654991198818347977535 66369807426542527862551818417574672890977772793800 08164706001614524919217321721477235014144197356854 81613611573525521334757418494684385233239073941433 34547762416862518983569485562099219222184272550254 25688767179049460165346680498862723279178608578438 38279679766814541009538837863609506800642251252051 17392984896084128488626945604241965285022210661186 30674427862203919494504712371378696095636437191728 74677646575739624138908658326459958133904780275900 99465764078951269468398352595709825822620522489407 72671947826848260147699090264013639443745530506820 34962524517493996514314298091906592509372216964615 15709858387410597885959772975498930161753928468138 26868386894277415599185592524595395943104997252468 08459872736446958486538367362226260991246080512438 84390451244136549762780797715691435997700129616089 44169486855584840635342207222582848864815845602850 60168427394522674676788952521385225499546667278239 86456596116354886230577456498035593634568174324112 51507606947945109659609402522887971089314566913686 72287489405601015033086179286809208747609178249385 89009714909675985261365549781893129784821682998948 72265880485756401427047755513237964145152374623436 45428584447952658678210511413547357395231134271661 02135969536231442952484937187110145765403590279934 40374200731057853906219838744780847848968332144571 38687519435064302184531910484810053706146806749192 78191197939952061419663428754440643745123718192179 99839101591956181467514269123974894090718649423196 15679452080951465502252316038819301420937621378559 56638937787083039069792077346722182562599661501421 50306803844773454920260541466592520149744285073251 86660021324340881907104863317346496514539057962685 61005508106658796998163574736384052571459102897064 14011097120628043903975951567715770042033786993600 72305587631763594218731251471205329281918261861258 67321579198414848829164470609575270695722091756711 67229109816909152801735067127485832228718352093539 65725121083579151369882091444210067510334671103141 26711136990865851639831501970165151168517143765761 83515565088490998985998238734552833163550764791853 58932261854896321329330898570642046752590709154814 16549859461637180270981994309924488957571282890592 32332609729971208443357326548938239119325974636673 05836041428138830320382490375898524374417029132765 61809377344403070746921120191302033038019762110110 04492932151608424448596376698389522868478312355265 82131449576857262433441893039686426243410773226978 02807318915441101044682325271620105265227211166039 66655730925471105578537634668206531098965269186205 64769312570586356620185581007293606598764861179104 53348850346113657686753249441668039626579787718556 08455296541266540853061434443185867697514566140680 07002378776591344017127494704205622305389945613140 71127000407854733269939081454664645880797270826683 06343285878569830523580893306575740679545716377525 42021149557615814002501262285941302164715509792592 30990796547376125517656751357517829666454779174501 12996148903046399471329621073404375189573596145890 19389713111790429782856475032031986915140287080859 90480109412147221317947647772622414254854540332157 18530614228813758504306332175182979866223717215916 07716692547487389866549494501146540628433663937900 39769265672146385306736096571209180763832716641627 48888007869256029022847210403172118608204190004229 66171196377921337575114959501566049631862947265473 64252308177036751590673502350728354056704038674351 36222247715891504953098444893330963408780769325993 97805419341447377441842631298608099888687413260472 15695162396586457302163159819319516735381297416772 94786724229246543668009806769282382806899640048243 54037014163149658979409243237896907069779422362508 22168895738379862300159377647165122893578601588161 75578297352334460428151262720373431465319777741603 19906655418763979293344195215413418994854447345673 83162499341913181480927777103863877343177207545654 53220777092120190516609628049092636019759882816133 23166636528619326686336062735676303544776280350450 77723554710585954870279081435624014517180624643626 79456127531813407833033625423278394497538243720583 53114771199260638133467768796959703098339130771098 70408591337464144282277263465947047458784778720192 77152807317679077071572134447306057007334924369311 38350493163128404251219256517980694113528013147013 04781643788518529092854520116583934196562134914341 59562586586557055269049652098580338507224264829397 28584783163057777560688876446248246857926039535277 34803048029005876075825104747091643961362676044925 62742042083208566119062545433721315359584506877246 02901618766795240616342522577195429162991930645537 79914037340432875262888963995879475729174642635745 52540790914513571113694109119393251910760208252026 18798531887705842972591677813149699009019211697173 72784768472686084900337702424291651300500516832336 43503895170298939223345172201381280696501178440874 51960121228599371623130171144484640903890644954440 06198690754851602632750529834918740786680881833851 02283345085048608250393021332197155184306354550076 68282949304137765527939751754613953984683393638304 74611996653858153842056853386218672523340283087112 32827892125077126294632295639898989358211674562701 02183564622013496715188190973038119800497340723961 03685406643193950979019069963955245300545058068550 19567302292191393391856803449039820595510022635353 61920419947455385938102343955449597783779023742161 72711172364343543947822181852862408514006660443325 88856986705431547069657474585503323233421073015459 40516553790686627333799585115625784322988273723198 98757141595781119635833005940873068121602876496286 74460477464915995054973742562690104903778198683593 81465741268049256487985561453723478673303904688383 43634655379498641927056387293174872332083760112302 99113679386270894387993620162951541337142489283072 20126901475466847653576164773794675200490757155527 81965362132392640616013635815590742202020318727760 52772190055614842555187925303435139844253223415762 33610642506390497500865627109535919465897514131034 82276930624743536325691607815478181152843667957061 10861533150445212747392454494542368288606134084148 63776700961207151249140430272538607648236341433462 35189757664521641376796903149501910857598442391986 29164219399490723623464684411739403265918404437805 13338945257423995082965912285085558215725031071257 01266830240292952522011872676756220415420516184163 48475651699981161410100299607838690929160302884002 69104140792886215078424516709087000699282120660418 37180653556725253256753286129104248776182582976515 79598470356222629348600341587229805349896502262917 48788202734209222245339856264766914905562842503912 7577102840279980663658254889264 8802545661017296702 66407655904290994568150652653053718294127033693137 85178609040708667114965583434347693385781711386455 87367812301458768712660348913909562009939361031029 16161528813843790990423174733639480457593149314052 97634757481193567091101377517210080315590248530906 69203767192203322909433467685142214477379393751703 44366199104033751117354719185504644902636551281622 88244625759163330391072253837421821408835086573917 71509682887478265699599574490661758344137522397096 83408005355984917541738188399944697486762655165827 65848358845314277568790029095170283529716344562129 64043523117600665101241200659755851276178583829204 19748442360800719304576189323492292796501987518721 27267507981255470958904556357921221033346697499235 63025494780249011419521238281530911407907386025152 27429958180724716259166854513331239480494707911915 32673430282441860414263639548000448002670496248201 79289647669758318327131425170296923488962766844032 32609275249603579964692565049368183609003238092934 59588970695365349406034021665443755890045632882250 54525564056448246515187547119621844396582533754388 56909411303150952617937800297412076651479394259029 89695946995565761218656196733786236256125216320862 86922210327488921865436480229678070576561514463204 69279068212073883778142335628236089632080682224680 12248261177185896381409183903673672220888321513755 60037279839400415297002878307667094447456013455641 72543709069793961225714298946715435784687886144458 12314593571984922528471605049221242470141214780573 45510500801908699603302763478708108175450119307141 22339086639383395294257869050764310063835198343893 41596131854347546495569781038293097164651438407007 07360411237359984345225161050702705623526601276484 83084076118301305279320542746286540360367453286510 57065874882256981579367897669742205750596834408697 35020141020672358502007245225632651341055924019027 42162484391403599895353945909440704691209140938700 12645600162374288021092764579310657922955249887275 84610126483699989225695968815920560010165525637567 85667227966198857827948488558343975187445455129656 34434803966420557982936804352202770984294232533022 57634180703947699415979159453006975214829336655566 15678736400536665641654732170439035213295435291694 14599041608753201868379370234888689479151071637852 90234529244077365949563051007421087142613497459561 51384987137570471017879573104229690666702144986374 64595280824369445789772330048764765241339075920434 01963403911473202338071509522201068256342747164602 43354400515212669324934196739770415956837535551667 30273900749729736354964533288869844061196496162773 44951827369558822075735517665158985519098666539354 94810688732068599075407923424023009259007017319603 62254756478940647548346647760411463233905651343306 84495397907090302346046147096169688688501408347040 54607429586991382966824681857103188790652870366508 32431974404771855678934823089431068287027228097362 48093996270607472645539925399442808113736943388729 40630792615959954626246297070625948455690347119729 96409089418059534393251236235508134949004364278527 13831591256898929519642728757394691427253436694153 23610045373048819855170659412173524625895487301676 00298865925786628561249665523533829428785425340483 08330701653722856355915253478445981831341129001999 20598135220511733658564078264849427644113763938669 24803118364453698589175442647399882284621844900877 76977631279572267265556259628254276531830013407092 23343657791601280931794017185985999338492354956400 57099558561134980252499066984233017350358044081168 55265311709957089942732870925848789443646005041089 22669178352587078595129834417295351953788553457374 26085902908176515578039059464087350612322611200937 31080485485263572282576820341605048466277504500312 62008007998049254853469414697751649327095049346393 82432227188515974054702148289711177792376122578873 47718819682546298126868581705074027255026332904497 62778944236216741191862694396506715157795867564823 99391760426017633870454990176143641204692182370764 88783419689686118155815873606293860381017121585527 26683008238340465647588040513808016336388742163714 06435495561868964112282140753302655100424104896783 52858829024367090488711819090949453314421828766181 03100735477054981596807720094746961343609286148494 17850171807793068108546900094458995279424398139213 50558642219648349151263901280383200109773868066287 79239718014613432445726400973742570073592100315415 08936793008169980536520276007277496745840028362405 34603726341655425902760183484030681138185510597970 56640075094260878857357960373245141467867036880988 06097164258497595138069309449401515422221943291302 17391253835591503100333032511174915696917450271494 33151558854039221640972291011290355218157628232831 82342548326111912800928252561902052630163911477247 33148573910777587442538761174657867116941477642144 11112635835538713610110232679877564102468240322648 34641766369806637857681349204530224081972785647198 39630878154322116691224641591177673225326433568614 61865452226812688726844596844241610785401676814208 08850280054143613146230821025941737562389942075713 62751674573189189456283525704413354375857534269869 94725470316566139919996826282472706413362221789239 03176085428943733935618891651250424404008952719837 87386480584726895462438823437517885201439560057104 81194988423906061369573423155907967034614914344788 63604103182350736502778590897578272731305048893989 00992391350337325085598265586708924261242947367019 39077271307068691709264625484232407485503660801360 46689511840093668609546325002145852930950000907151 05823626729326453738210493872499669933942468551648 32611341461106802674466373343753407642940266829738 65220935701626384648528514903629320199199688285171 83953669134522244470804592396602817156551565666111 35982311225062890585491450971575539002439315351909 02107119457300243880176615035270862602537881797519 47806101371500448991721002220133501310601639154158 95780371177927752259787428919179155224171895853616 80594741234193398420218745649256443462392531953135 10331147639491199507285843065836193536932969928983 79149419394060857248639688369032655643642166442576 07914710869984315733749648835292769328220762947282 38153740996154559879825989109371712621828302584811 23890119682214294576675807186538065064870261338928 22994972574530332838963818439447707794022843598834 10035838542389735424395647555684095224844554139239 41000162076936368467764130178196593799715574685419 46334893748439129742391433659360410035234377706588 86778113949861647874714079326385873862473288964564 35987746676384794665040741118256583788784548581489 62961273998413442726086061872455452360643153710112 74680977870446409475828034876975894832824123929296 05829486191966709189580898332012103184303401284951 16203534280144127617285830243559830032042024512072 87253558119584014918096925339507577840006746552603 14461670508276827722235341911026341631571474061238 50425845988419907611287258059113935689601431668283 17632356732541707342081733223046298799280490851409 47903688786878949305469557030726190095020764334933 59106024545086453628935456862958531315337183868265 61786227363716975774183023986006591481616404944965 01173213138957470620884748023653710311508984279927

Oui, ce sont bien les 15’000 premières décimales de Pi !

(ajout du 3.14 (pi-day…) 2012:)

L’algorithme utilisé s’appelle “ ” et il est du à Rabinowitz and Wagon. La référence suivante explique son fonctionnement

\[altmetric doi="10.1007/978-3-319-32377-0\_16" float="right"\]Jeremy Gibbons “ ” (2006), The American Mathematical Monthly 4 (113) p. 318-328 DOI>