Recherche de nombres curieux avec Maxima
Vous trouverez sur cette page quelques séries de nombres curieux, répondant à un ou plusieurs critères à la fois (par exemple les nombres de Fibonacci qui sont également premiers). J'ai personnellement calculée et vérifiée chacune de ses séries avec le logiciel Maxima. Pour chaque paragraphe le programme permettant d'obtenir les nombres est donné, ce qui vous permet de poursuivre la recherche de la série de nombres sous Maxima.
Les
nombres premiers |
Un nombre est premier s'il ne possède que deux diviseurs : 1 et lui-même.
Rappel : 1 n'est pas premier, et 2 est le seul nombre premier pair
Dans le logiciel Maxima le test de primalité est la fonction primed(i) : elle renvoie True ou False selon que l'entier i est premier ou pas.
Le programme suivant affiche dans Maxima tous les nombres premiers compris entre 2 et 200 :
for i from 2 thru 200 do if primep(i) then print(i);
Résultat :
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
101
103
107
109
113
127
131
137
139
149
151
157
163
167
173
179
181
191
193
197
199
Les
nombres premiers jumeaux |
Deux nombres premiers consécutifs sont jumeaux lorsque l'écart entre les deux nombres premiers est égal à 2.
Le programme suivant affiche dans Maxima toutes les paires de nombres premiers jumeaux inférieurs à 200 :
for i from 1 thru 200 do if primep(i) and primep(i+2) then print(i,i+2);
Résultat :
3 5
5 7
11 13
17 19
29 31
41 43
59 61
71 73
101 103
107 109
137 139
149 151
179 181
191 193
197 199
Les
nombres premiers triplés |
Trois nombres premiers consécutifs sont triplés s'il sont de la forme p, p+2 et p+6 ou bien de la forme p, p+4, p+6.
Le programme suivant affiche dans Maxima tous les nombres premiers triplés de la forme p, p+2 et p+6 inférieurs à 1000 :
for i from 1 thru 1000 do if primep(i) and primep(i+2) and primep(i+6) then print(i,i+2,i+6);
Résultat :
5 7 11
11 13 17
17 19 23
41 43 47
101 103 107
107 109 113
191 193 197
227 229 233
311 313 317
347 349 353
461 463 467
641 643 647
821 823 827
857 859 863
881 883 887
Le programme suivant affiche dans Maxima tous les nombres premiers triplés de la forme p, p+4 et p+6 inférieurs à 1000 :
for i from 1 thru 1000 do if primep(i) and primep(i+4) and primep(i+6) then print(i,i+4,i+6);
Résultat :
7 11 13
13 17 19
37 41 43
67 71 73
97 101 103
103 107 109
193 197 199
223 227 229
277 281 283
307 311 313
457 461 463
613 617 619
823 827 829
853 857 859
877 881 883
Les
nombres premiers quadruplés et plus |
Quatre nombres premiers consécutifs sont quadruplés s'il sont de la forme p, p+2, p+6, et p+8.
Le programme suivant affiche dans Maxima tous les nombres premiers quadruplés inférieurs à 20 000 :
for i from 1 thru 20000 do if primep(i) and primep(i+2) and primep(i+6) and primep(i+8) then print(i,i+2,i+6,i+8);
Résultat :
5 7 11 13
11 13 17 19
101 103 107 109
191 193 197 199
821 823 827 829
1481 1483 1487 1489
1871 1873 1877 1879
2081 2083 2087 2089
3251 3253 3257 3259
3461 3463 3467 3469
5651 5653 5657 5659
9431 9433 9437 9439
13001 13003 13007 13009
15641 15643 15647 15649
15731 15733 15737 15739
16061 16063 16067 16069
18041 18043 18047 18049
18911 18913 18917 18919
19421 19423 19427 19429
Cas des quintuplets et des sextuplets :
Le programme suivant affiche dans Maxima tous les nombres premiers quintuplés de la forme p, p+2, p+6, p+8, et p+12 inférieurs à 20 000 :
for i from 1 thru 20000 do if primep(i) and primep(i+2) and primep(i+6) and primep(i+8) and primep(i+12) then print(i,i+2,i+6,i+8,i+12);
Résultat :
5 7 11 13 17
11 13 17 19 23
101 103 107 109 113
1481 1483 1487 1489 1493
16061 16063 16067 16069 16073
19421 19423 19427 19429 19433
Le programme suivant affiche dans Maxima tous les nombres premiers quintuplés de la forme p, p+4, p+6, p+10, et p+12 inférieurs à 20 000 :
for i from 1 thru 20000 do if primep(i) and primep(i+4) and primep(i+6) and primep(i+10) and primep(i+12) then print(i,i+4,i+6,i+10,i+12);
Résultat :
7 11 13 17 19
97 101 103 107 109
1867 1871 1873 1877 1879
3457 3461 3463 3467 3469
5647 5651 5653 5657 5659
15727 15731 15733 15737 15739
16057 16061 16063 16067 16069
19417 19421 19423 19427 19429
Le programme suivant affiche dans Maxima tous les nombres premiers sextuplés de la forme p, p+4, p+6, p+10, p+12, et p+16 inférieurs à 100 000 :
for i from 1 thru 100000 do if primep(i) and primep(i+4) and primep(i+6) and primep(i+10) and primep(i+12) and primep(i+16) then print(i,i+4,i+6,i+10,i+12,i+16);
Résultat :
7 11 13 17 19 23
97 101 103 107 109 113
16057 16061 16063 16067 16069 16073
19417 19421 19423 19427 19429 19433
43777 43781 43783 43787 43789 43793
Les
nombres parfaits |
Un nombre est parfait s'il est égal à la somme de ses diviseurs propres (c'est-à-dire ses diviseurs autres que le nombre lui-même).
Exemple :
On peut également dire qu'un nombre est parfait s'il est égal à la moitié de la somme de tous ses diviseurs (y compris le nombre lui-même cette fois).
Les fonctions utiles dans Maxima sont :
Le programme suivant affiche dans Maxima tous les nombres parfaits compris entre 1 et 1000 :
for i from 1 thru 1000 do if divsum(i)=2*i then print(i);
Voici les premiers nombres parfaits :
6
28
496
8 128
33 550 336
8 589 869 056
137 438 691 328
2 305 843 008 139 952 128
2 658 455 991 569 831 744 654 692 615 953 842 176
etc.
Quel est le prochain nombre parfait après 100 000 ? Nous allons cette fois utiliser la boucle while de Maxima afin que le programme s'arrête dès qu'il trouve un nombre parfait :
i:100000$
while divsum(i)#2*i do (i:i+1)$
print(i," est un nombre parfait");
Résultat :
33550336 est un nombre parfait
Remarque : dans Maxima l'opérateur # signifie "différent de" (ou "non égal").
Les
nombres de Fibonacci |
La suite des nombres de Fibonacci est définie par Fn = Fn-1 + Fn-2 avec F1=F2=1
En clair chaque élément de la suite est égal à la somme des deux éléments précédents, et les deux premiers éléments de la suite valent 1.
Le programme Maxima suivant affiche les 20 premiers nombres de Fibonnaci :
a:1;
b:1;
c:a+b;
for i from 1 thru 20 do (print(a),a:b,b:c,c:a+b);
Remarque :
Dans un programme Maxima l'opérateur : est l'opérateur d'affectation : a:1 signifie la variable a prend la valeur 1.
Résultat :
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
Remarque :
Dans le programme précédent on commence au début de la suite de Fibonacci : les deux premiers termes sont 1 et 1. Si on veut tester par exemple les termes de la suite à partir du 2000ème terme il faut remplacer les lignes a:1; et b:1; au début du progrmme par :
n:2000$
a:floor(float(((1+sqrt(5))^n-(1-sqrt(5))^n)/(sqrt(5)*2^n)))$
b:floor(float(((1+sqrt(5))^(n+1)-(1-sqrt(5))^(n+1))/(sqrt(5)*2^(n+1))))$
n représente le rang de départ, a prend directement la valeur Fn et b la valeur Fn+1.
|
Les
nombres premiers de Fibonacci |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont premiers.
Remarque :
La fonction primep(a) de Maxima teste si l'entier a est un nombre premier.
Le programme Maxima suivant teste les 200 premiers nombres de Fibonnacci et affiche ceux qui sont premiers :
a:1;
b:1;
c:a+b;
for i from 1 thru 200 do (if primep(a) then print(a),a:b,b:c,c:a+b);
Résultat :
2
3
5
13
89
233
1597
28657
514229
433494437
2971215073
99194853094755497
1066340417491710595814572169
19134702400093278081449423917
Le programme Maxima suivant teste les 2000 premiers nombres de Fibonnacci et affiche ceux qui font partie d'une paire de nombres premiers jumeaux :
a:1;
b:1;
c:a+b;
for i from 1 thru 2000 do (if primep(a) and (primep(a+2) or primep(a-2)) then print(a),a:b,b:c,c:a+b);
Résultat :
3
5
13
|
Les
carrés de Fibonacci |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont des carrés parfaits.
Le programme Maxima suivant teste les 2000 premiers nombres de Fibonnacci et affiche ceux qui sont des carrés parfaits :
a:1;
b:1;
c:a+b;
for i from 1 thru 2000 do (r:sqrt(a), if floor(r)=r then print(a),a:b,b:c,c:a+b);
La variable r est égale à la racine carrée du nombre de Fibinacci a.
La fonction floor(r) de Maxima renvoie la partie entière de r.
Le nombre de Fibonacci a est un carré parfait si la partie entière de sa racine carrée est égale à la racine carrée elle-même.
Résultat :
1 = 1^2
144 = 12^2
Conclusion : parmi les 2000 premiers nombres de Fibonacci, seulement 2 sont des carrés parfaits : 1 et 144.
|
Les
cubes de Fibonacci |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont des cubes parfaits.
Le programme Maxima suivant teste les 1000 premiers nombres de Fibonnacci et affiche ceux qui sont des cubes parfaits :
a:1;
b:1;
c:a+b;
for i from 1 thru 1000 do (r:a^(1/3), if floor(r)=r then print(a),a:b,b:c,c:a+b);
La variable r est égale à la racine cubique (a^(1/3)) du nombre de Fibinacci a.
La fonction floor(r) de Maxima renvoie la partie entière de r.
Le nombre de Fibonacci a est un cube parfait si la partie entière de sa racine cubique est égale à la racine cubique elle-même.
Résultat :
1 = 1^3
8 = 2^3
Conclusion : parmi les 1000 premiers nombres de Fibonacci, seulement 2 sont des cubes parfaits : 1 et 8.
|
Les
nombres de Fibonacci "deux fois premiers" |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont égaux à 2p, où p est un nombre premier.
La fonction mod(a,n) de Maxima renvoie le reste de la division entière de a par n (fonction modulo) : mod(a,2) vaut 0 si l'entier a est un multiple de 2.
Le programme Maxima suivant teste les 4000 premiers nombres de Fibonnacci et affiche ceux qui sont de la forme 2p avec p premier :
a:1;
b:1;
c:a+b;
for i from 1 thru 4000 do (if (mod(a,2)=0 and primep(a/2)) then print(a),a:b,b:c,c:a+b);
Résultat :
34 = 2x17
Conclusion : parmi les 4000 premiers nombres de Fibonacci, seul 34 est égal au double d'un nombre premier.
Les
nombres de Fibonacci "trois fois premiers" |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont égaux à 3p, où p est un nombre premier.
La fonction mod(a,n) de Maxima renvoie le reste de la division entière de a par n (fonction modulo) : mod(a,3) vaut 0 si l'entier a est un multiple de 3.
Le programme Maxima suivant teste les 4000 premiers nombres de Fibonnacci et affiche ceux qui sont de la forme 3p avec p premier :
a:1;
b:1;
c:a+b;
for i from 1 thru 4000 do (if (mod(a,3)=0 and primep(a/3)) then print(a),a:b,b:c,c:a+b);
Résultat :
21 = 3x7
Conclusion : parmi les 4000 premiers nombres de Fibonacci, seul 21 est égal au triple d'un nombre premier.
Les
nombres de Fibonacci "quatre fois premiers" |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont égaux à 4p, où p est un nombre premier.
La fonction mod(a,n) de Maxima renvoie le reste de la division entière de a par n (fonction modulo) : mod(a,4) vaut 0 si l'entier a est un multiple de 4.
Le programme Maxima suivant teste les 100 000 premiers nombres de Fibonnacci et affiche ceux qui sont de la forme 4p avec p premier :
a:1;
b:1;
c:a+b;
for i from 1 thru 100000 do (if (mod(a,4)=0 and primep(a/4)) then print(a),a:b,b:c,c:a+b);
Résultat :
8 = 4x2
Conclusion : parmi les 100 000 premiers nombres de Fibonacci, seul 8 est égal à 4 fois un nombre premier.
Les
nombres de Fibonacci "cinq fois premiers" |
Il s'agit des nombres présents dans la suite de Fibonacci (1 1 2 3 5 8 13 etc.) et qui sont égaux à 5p, où p est un nombre premier.
La fonction mod(a,n) de Maxima renvoie le reste de la division entière de a par n (fonction modulo) : mod(a,5) vaut 0 si l'entier a est un multiple de 5.
Le programme Maxima suivant teste les 4000 premiers nombres de Fibonnacci et affiche ceux qui sont de la forme 5p avec p premier :
a:1;
b:1;
c:a+b;
for i from 1 thru 4000 do (if (mod(a,5)=0 and primep(a/5)) then print(a),a:b,b:c,c:a+b);
Résultat :
55 = 5x11
Conclusion : parmi les 4000 premiers nombres de Fibonacci, seul 55 est égal à 5 fois un nombre premier.
Statistiques dans la suite de Fibonacci |
Le programme Maxima suivant teste les 1000 premiers nombres de Fibonnacci et compte le nombre de nombres premiers parmi eux :
a:1$
b:1$
c:a+b$
s:0$
for i from 1 thru 1000 do (if primep(a) then s:s+1,a:b,b:c,c:a+b)$
print("Résultat :",s);
En remplaçant le test primep(a) par exemple par mod(a,3)=0 il est possible de compter le nombre de multiples de 3, ou autres.
Remarque concernant la fin de ligne des programmes Maxima :
Voici quelques résultats constatés en analysant différents critères dans la suite de Fibonacci :
Parmi les 1 000 premiers nombres de Fibonacci il y a :
Parmi les 10 000 premiers nombres de Fibonacci il y a :
|
Les
nombres de Catalan |
Il s'agit des nombres de la forme (2n)!/(n!*(n + 1)!).
Le programme suivant affiche dans Maxima les 100 premiers nombres de Catalan :
for n from 1 thru 100 do print((2*n)!/(n!*(n+1)!));
Résultat
12
5
14
42
132
429
1430
4862
16796
58786
208012
742900
2674440
9694845
35357670
129644790
477638700
1767263190
6564120420
24466267020
91482563640
343059613650
1289904147324
4861946401452
18367353072152
69533550916004
263747951750360
1002242216651368
3814986502092304
14544636039226909
55534064877048198
212336130412243110
812944042149730764
3116285494907301262
11959798385860453492
45950804324621742364
176733862787006701400
680425371729975800390
2622127042276492108820
10113918591637898134020
39044429911904443959240
150853479205085351660700
583300119592996693088040
2257117854077248073253720
8740328711533173390046320
33868773757191046886429490
131327898242169365477991900
509552245179617138054608572
1978261657756160653623774456
7684785670514316385230816156
29869166945772625950142417512
116157871455782434250553845880
451959718027953471447609509424
1759414616608818870992479875972
6852456927844873497549658464312
26700952856774851904245220912664
104088460289122304033498318812080
405944995127576985730643443367112
1583850964596120042686772779038896
6182127958584855650487080847216336
24139737743045626825711458546273312
94295850558771979787935384946380125
368479169875816659479009042713546950
1440418573150919668872489894243865350
5632681584560312734993915705849145100
22033725021956517463358552614056949950
86218923998960285726185640663701108500
337485502510215975556783793455058624700
1321422108420282270489942177190229544600
5175569924646105559418940193995065716350
20276890389709399862928998568254641025700
79463489365077377841208237632349268884500
311496878311103321137536291518809134027240
1221395654430378811828760722007962130791020
4790408930363303911328386208394864461024520
18793142726809884575211361279087545193250040
73745243611532458459690151854647329239335600
289450081175264899454283846029490767264392230
1136359577947336271931632877004667456667613940
4462290049988320482463241297506133183499654740
17526585015616776834735140517915655636396234280
68854441132780194707888052034668647142985206100
270557451039395118028642463289168566420671280440
1063353702922273835973036658043476458723103404520
4180080073556524734514695828170907458428751314320
16435314834665426797069144960762886143367590394940
64633260585762914370496637486146181462681535261000
254224158304000796523953440778841647086547372026600
1000134600800354781929399250536541864362461089950800
3935312233584004685417853572763349509774031680023800
15487357822491889407128326963778343232013931127835600
60960876535340415751462563580829648891969728907438000
239993345518077005168915776623476723006280827488229600
944973797977428207852605870454939596837230758234904050
3721443204405954385563870541379246659709506697378694300
14657929356129575437016877846657032761712954950899755100
57743358069601357782187700608042856334020731624756611000
227508830794229349661819540395688853956041682601541047340
896519947090131496687170070074100632420837521538745909320
Obtenir un nombre réel en haute précision |
Pour afficher dans Maxima un nombre réel en haute précision (avec "beaucoup" de décimales) il faut effectuer les 3 actions suivantes :
Le programme suivant affiche par exemple les 2000 premières décimales du nombre Pi :
set_display('ascii)$
fpprec : 2000$
bfloat(%pi);
Le programme suivant affiche les 10000 premières décimales du nombre e (base du logarithme népérien) :
set_display('ascii)$
fpprec : 10000$
bfloat(%e);
Et le programme suivant affiche les 4000 premières décimales du nombre d'or :
set_display('ascii)$
fpprec : 4000$
bfloat((sqrt(5)+1)/2);
Remarque concernant la fin de ligne des programmes Maxima :
Téléchargement et documentation de Maxima |
Maxima est un logiciel de calcul formel, totalement libre et gratuit. Il dispose de quelques capacités graphiques. Maxima est multiplateforme, et existe en version Windows et Linux.
Installer Maxima sous Windows :
Télécharger Maxima version 5.20.1 en français pour Windows
Télécharger Maxima version 5.19.1 en français pour Windows
Installer Maxima sous Linux :
Pour installer Maxima sous Linux Ubuntu, exécutez la ligne de commande suivante dans un shell en tant que root :
apt-get install maxima
Pour lancer Maxima en mode texte sous Linux exécutez la commande suivante dans un shell :
maxima
Pour quitter Maxima en mode texte sous Linux exécutez la commande suivante dans maxima :
quit();
Pour installer une interface graphique de Maxima sous Linux Ubuntu, exécutez une des commandes suivantes dans un shell en tant que root :
apt-get install xmaxima
apt-get install wxmaxima
Pour lancer Maxima en mode graphique sous Linux exécutez une des deux commandes suivantes dans un shell :
xmaxima
wxmaxima
Remarques :
Documents PDF pour utiliser Maxima :
Utilisation de Maxima au lycée
Exemple d'utilisation de Maxima