Fibonacci | Dr. Goulu

Suites infinies en Python

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

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

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

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

La classe Sequence

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

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

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

=Sequence(containf= )

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

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

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

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

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

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

Compact et presque clair, non ?

Dérivation

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

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

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

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

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

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

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

Le dictionnaire OEIS

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

\[python\]

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

\[0\]

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

\[id\]

=seqs

\[id\]

# on les ajoute au dictionnaire … seqs

\[id\]

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

\[/python\]

Performance

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

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

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

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

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

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

Tests

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

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

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

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

Débogage… de l’OEIS !

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

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

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

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

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

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

Notes

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

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

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

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

Un nombre d’or, mais flottant

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

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

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

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

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

La Matrice salvatrice

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

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

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

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

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

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

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

Vers les pétaoctets et au delà …

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

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

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

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

(mon premier meme … désolé …)

Et modulo 1000000007 ?

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

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

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

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

\[gist id="f56725fa32fbb4840c855a8309662c9d"\]

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

Prochaine étape : trouver la correspondante …

Références

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

Nombre d'or et abeilles

Sun, 03 Jul 2016 00:00:00 +0000

Le ou “divine proportion"représente parait-il le rapport le plus esthétiquement parfait que l’on puisse trouver dans la nature, dans les monuments antiques, les œuvres d’art célèbres ou un simple rectangle. Alors dites : lequel de ces rectangles vous parait-il le mieux proportionné ?

Quel rectangle vous semble le mieux proportionné ?

Si vous avez répondu 5, vous avez la même préférence que les 34% des participants à un sondage identique , mais ce n’est pas un rectangle d’or. Le rectangle d’or, c’est le 2, choisi par 18% des gens, mais aussi le 9, choisi par 5%, soit nettement moins que les 11% de moyenne. Autrement dit : vous n’êtes statistiquement pas foutus de trouver du divin dans un rectangle…

Ce fameux “nombre d’or” Φ est défini historiquement comme le rapport de deux nombres a et b satisfaisant l’équation $a/b = (a+b)/a$. La solution est $\phi = a/b = (1+\sqrt{5})/2$ soit approximativement 1.6180339887. Et ça c’est approximativement, parce qu’avec seulement 6 décimales, 1.618034 peut déjà être pas mal d’autres choses selon le génial . Par exemple :

$$7^{1/3}-6^{3/4}/13$$
$$3/18541$$
$$Re((20+5i)^{13/14})$$
$$Im((4-24i)^{1/11})$$
(2,23/19)
et d’autres nombres encore

Et avec seulement 4 décimales, 1.6180 correspond à l’arrondi de dizaines, voire de centaines d’expressions répertoriées dans l’inverseur, dont .

Bref, quand quelqu’un vous dit que le nombre d’or est présent dans une construction antérieure à Euclide (300 avant JC), ou une structure “naturelle”, il faut qu’il le prouve par des mesures précises au millionième pour obtenir 6 ou 7 décimales, parce que 1.62 c’est plus proche de 6/37037 que je trouve très beau aussi, voire divin. Ou de 9/55555, nombre si magnifique que je m’empresse de le baptiser “nombre de platine” pour la postérité.

L’homme vitruvien de Léonard de Vinci. Illustration Wikipédia

Ou alors il faut prouver que la construction géométrique ou mathématique de l’oeuvre aboutit bien à $\\phi=(1+\\sqrt{5})/2$ . Par exemple dans le célèbre de Léonard de Vinci, comme chacun sait. Sauf que non. De Vinci ne fait nulle part référence au nombre d’or ni dans son texte explicatif de la figure, ni dans sa construction géométrique. Les proportions que Vinci utilise sont celles conseillées par l’architecte romain 1/10, 1/4, 1/8 et 1/6 . Il faut bien chercher pour trouver un quasi nombre d’or dans cette oeuvre. Le plus proche est celui entre la hauteur du corps (482 pixels sur l’image) et la distance entre le nombril et la plante des pieds (294 pixels), qui donne environ 1.639 . Même pas 2 décimales exactes et pas de construction géométrique : ce n’est pas le nombre d’or, désolé. Ni celui de platine, grande tristesse… Alors je désigne en vitesse la proportion 294/482 “nombre de ” et voilà : Léonard de Vinci connaissait le nombre de scandium 500 ans avant vous et moi. Wow !

En fait il n’y a que deux manières simples de tomber pile sur le nombre d’or:

Construction d’un rectangle d’or avec règle et compas (source : Maths et Tiques)

calculer ou construire explicitement deux nombres a et b tels que $a/b = (a+b)/a = (1+\\sqrt{5})/2$. Par exemple dans la construction ci-contre, où l’on part d’un triangle rectangle ABC dont le côté AC est la moitié du côté AB et que l’on reporte l’hypoténuse en prolongement du côté AC, on forme un “rectangle d’or” dont les côtés a=AD et b=AB sont tels que a/b=Φ. En passant, les A3, A4, A5 etc ne sont pas des rectangles d’or. Les côtés du papier a et b sont définis de manière à ce que le rapport soit préservé si on coupe ou plie la feuille en deux. On a donc $a/b = 2b/a = \\sqrt{2} = 1.4142135624$ qui est très différent de Φ.
Carrés de Fibonacci

A partir de la , suite dans laquelle chaque terme est la somme des deux précédents : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 etc ( ). Il se trouve que le rapport entre deux nombres consécutifs de la suite converge vers $\\phi : \\lim\_{n \\to \\infty} \\frac{\\mathcal F\_{n}}{\\mathcal F\_{n-1}} = \\phi$. On voit donc qu’en juxtaposant des carrés dont les côtés correspondent à la suite de Fibonacci comme ci-contre, le rapport des cotés du rectangle va converger vers Φ au fur et à mesure qu’on ajoute des carrés.

Voilà les deux constructions mathématiques simples qui conduisent au nombre d’or. Aucune des deux ne correspond à un phénomène naturel à ma connaissance.

spirale d’or en vert, et spirale logarithmique l’approchant en rouge

Certains ont pourtant vu le nombre d’or dans des spirales comme celle de la coquille du . Effectivement, en traçant des quart de cercles dans chaque carré de Fibonacci on dessine la “ ” qui est très proche d’une d’équation $r = a.e^{b\\theta}$ particulière, celle obtenue pour $b=3\\phi+2$. Mais il existe une infinité de spirales logarithmiques avec des paramètre b différents, et certaines se retrouvent dans la nature car elles résultent d’équations différentielles assez simples. C’est le cas de la coquille du nautile, mais son b est nettement inférieur à 3Φ+2, donc non, la coquille du nautile n’a rien à voir avec le nombre d’or .

Et puis il y a la : des graines de tournesol aux pommes de pin, beaucoup de structures botaniques croissent en faisant de jolies spirales apparentes, les “parastiches”. Certaines tournent dans un sens et s’entrecroisent avec d’autres orientées en sens inverse, et Ô stupeur, le nombre de parastiches dans chaque sens correspond toujours à deux termes consécutifs de la suite de Fibonacci.

Et le rapport entre deux termes de la suite de Fibonacci étant “proche” de Φ. 34/21= 1.619047… pour la marguerite ci-dessus. Serait-ce la Signature du Grand Architecte de Toutes Choses ?

Non, c’est juste le résultat d’une optimisation. Ces structures sont issues d’un qui produit des feuilles, pétales, graines etc. à intervalles réguliers. Pour maximiser l’efficacité de la plante, il faut que chaque organe accède au maximum de lumière en faisant le moins d’ombre possible aux autres, et pour cela il faut qu’il s’éloigne du centre dans une direction différente des précédents, et ceci, étonnamment, forme les parastiches spiraux. Deux chercheurs français, Stéphane Douady et Yves Coudert ont montré en 1992 qu’il n’y a pas besoin d’un organisme vivant pour produire de telles structures. Ils ont généré des gouttes d’un à intervalles réguliers au centre d’une plaque soumise à un champ magnéique radial. Les gouttes se repoussent mutuellement et lorsque’elles sont produites à une cadence assez élevée, elles forment des “parastiches” spiraux :

Evidemment les matheux se sont aussi attaqués au problème. En 1907 déjà, un dénommé a montré que l’optimum était atteint lorsque chaque graine (ou pétale ou feuille etc…) s’éloignait de la précédente selon un “ ” de $\\frac{2 \\pi}{\\phi+1}=137.5^{\\circ}$ environ, et que la structure formait bien des parastiches dont le nombre dans chaque sens correspond à deux termes consécutifs de la suite de Fibonacci. Joli. Très joli, même.

Nid naturel d’Apis Dorsata par Muhammad Mahdi Karim (CC Wikipedia)

Alors quand Tâniel m’a parlé de son bouquin sur le nombre d’or dans les nids d’abeilles j’étais un peu méfiant mais pas fondamentalement sceptique a priori. Les abeilles sont d’excellentes optimisatrices, on sait que leurs rayons d’ hexagonales à fond rhombique (3 losanges) permet de minimiser la cire utilisée pour produire un maximum d’alvéoles de petit diamètre ,

Sauf que pas tout à fait. En 1964, a montré qu’il existait une forme de fond d’alvéole qui permettrait aux abeilles d’économiser 0.35% de cire. Peut-être la trouveront-elles aussi après quelques millions d’années d’évolution. En attendant, ni le nombre d’or ni l’angle d’or n’apparaissent dans la des alvéoles, car on n’y trouve ni pentagone, ni nombres de Fibonacci, ni rien qui ressemble à un apex.

Donc la “découverte” que les nids d’abeilles elliptiques s’inscrivent dans un cadre rectangulaire dont le rapport vaut 1.6±0.4 me semble plus probablement due à une “loi inhérente du Cosmos” comme la résistance des matériaux qu’à un nombre d’or vachement moins universel que e, pi, ou , désolé…

Références

Cyril Jaquier, Kévin Drapel “ ” Projet STS EPFL, 25 avril 2005
Jean-Paul Krivine “ ”, SPS n° 278, août 2007
Christiane Rousseau, “ ”, 2008, Accromath, Vol 3, p.8-11
S. Douady et Y. Couder, La physique des spirales végétales, La Recherche, janvier 1993, p. 26
Daniel Favre “ ”, 2016, Blurb
Philip Ball “ ”, 2016 April 7 sur Nautilus
Alain Satabin “ ”, 2004, Dossier Pour la Science, N°44