La spirale des nombres premiers de Ulam Renée De Graeve et Bernard Parisse 2018

Contents

• 1  Introduction
• 2  Programme qui écrit les entiers de 1 à $n$ en spirale
• 3  Programme écrivant les chiffres de 1 à $n$ au fur et à mesure
  • 3.1  Déscription de l’algorithme
  • 3.2  Le programme des nombres premiers écrits en spirale au fur et à mesure
  • 3.3  La spirale des nombres premiers et des premiers jumeaux
  • 3.4  La spirale des nombres premiers et des premiers jumeaux débutant à $n0$
• 4  Le programme des nombres premiers écrits en spirale avec leurs affixes
  • 4.1  L’affixe des nombres entiers $n \geq 1$ écrits selon une spirale: faffixe
  • 4.2  La spirale des nombres premiers $\geq 1$ avec la fonction faffixe
• 5  La spirale des nombres premiers $n \geq n0$ avec la fonction faffixe
  • 5.1  Programme n’affichant que les nombres premiers selon un carré rouge
  • 5.2  Exercice : saffixe une amélioration de faffixe
• 6  La spirale des carrés rouge représentant les nombres premiers
• 7  Programmes qui ne teste que les nombres $6k-1$ et $6k+1$
  • 7.1  La spirale des nombres premiers débutant à 1 ou à $n0$
  • 7.2  La spirale des nombres premiers et les nombres premiers jumeaux débutant à 1 ou à $n0$
• 8  Les programmes utilisés

1  Introduction

En 1963, lors d’une communication ennuyeuse Stanislas M. Ulam de l’université de Los Alamos écrit les entiers naturels selon une spirale, et il entoure les nombres premiers (ici ils seront écrits en rouge). À sa grande surprise il obtient beaucoup d’alignement.
Voici la spirale de Ulam et le crible d’Eratosthène pour les entiers de 1 à 56 :
axes=0;spirale(48),segment(4.1-3*i,4.1+4*i),tabprem6(4.3-3*i,48) exe

2  Programme qui écrit les entiers de 1 à $n$ en spirale

On peut choisir :

1. soit constituer la spirale au fur et à mesure : c’est le choix de Bernard Parisse.
2. soit écrire une fonction $f$ qui à un entier de $1..n$ renvoie son affixe dans la spirale : c’est le choix de Renée De Graeve.

3  Programme écrivant les chiffres de 1 à $n$ au fur et à mesure

3.1  Déscription de l’algorithme

Les nombres à écrire sont écrits selon 4 directions : on appelle dir la variable qui indique la direction :
si dir vaut 1, on écrit les nombres de gauche à droite selon l’axe réel,
si dir vaut i, on écrit les nombres de bas en haut selon l’axe imaginaire,
si dir vaut -1, on écrit les nombres de droite à gauche selon l’axe réel,
si dir vaut -i, on écrit les nombres de haut en bas selon l’axe imaginaire.
Au départ on écrit le nombre 1 à l’origine du repère puis,
on écrit le nombre 2 de gauche à droite selon l’axe réel (i.e à droite du 1 ) puis on change de direction et
on écrit le nombre (3) de bas en haut selon l’axe imaginaire (i.e au dessus du 2), puis on change de direction et
on écrit 2 nombres (4 et 5) de droite à gauche selon l’axe réel,
puis on change de direction et
on écrit 2 nombres (6 et 7) de haut en bas gauche à droite selon l’axe réel, puis on change de direction et
on écrit 3 nombres (8,9,10) de gauche à droite selon l’axe réel puis on change de direction et
on écrit 3 nombres (11,12,13) de bas en haut selon l’axe imaginaire, puis on change de direction et
on écrit 4 nombres (14,15,16,17) de droite à gauche selon l’axe réel, puis on change de direction et
on écrit 4 nombres (18,19,20,21) de haut en bas selon l’axe imaginaire, puis on change de direction et
on écrit 5 nombres (22,23,24,25,26) de gauche à droite selon l’axe réel puis on change de direction et
on écrit 5 nombres (27,28,29,30,31) de bas en haut selon l’axe imaginaire, puis on change de direction etc....
Combien faut-il écrire d’entiers sans changer de direction ?
Soit k le nombre d’entiers à écrire sans changer de direction.
Au début k vaut 0 et dir vaut 1 eton écrit le nombre 1 à l’origine du repère puis, on augmente k de 1 i.e k vaut 1, donc on écrit 2 à droite de 1, puis on change de direction i.e. dir:=dir*i.
Maintenant dir vaut i et on ne change pas k donc on écrit 3 au dessus de 2, puis on change de direction i.e. dir:=dir*i.
Maintenant dir vaut -1 et on augmente k de 1, i.e k vaut 2 donc on écrit 4,5 de droite à gauche selon l’axe réel, puis on change de direction i.e. dir:=dir*i.
Maintenant dir vaut -i, on ne change pas k donc on écrit 6,7 de haut en bas puis on change de direction i.e. dir:=dir*i.
Maintenant dir vaut 1 et on augmente k de 1,....
Donc k augmente donc de 1 lorsque la direction vaut 1 ou -1 i.e. quand la direction est un nombre réel on augmente k de 1.

3.2  Le programme des nombres premiers écrits en spirale au fur et à mesure

On veux avoir avoir un programme dans lequel les nombres entiers de 1 à $n$ sont écrits selon une spirale, en écrivant les nombres premiers en rouge.
Écrire les nombres n’est valable que losque $n$ est petit. On va donc aussi écrire dans lequel on ne dessine que des carr’es rouges à l’emplacement des nombres premiers, les nombres entiers de 1 à $n$ étant bien sûr écrits selon une spirale.
Ici on écrit les 2 programmes en un seul grâce au paramètre nombre :
lorsque nombre vaut 1 on écrit les nombres selon une spirale en écrivant les nombres premiers en rouge et
lorsque nombre vaut 0 on ne dessine que des carr’es rouges à l’emplacement des nombres premiers.
On tape :

fonction spirale2prem(n,nombre=0)
  local L,j,k,N,z,dir;
  N:=1; z:=0; L:=[];
  dir:=1;
  k:=0;
  si nombre alors
     L.append(couleur(legende(z,N),0));
  fsi; 
  tantque N<n faire
    si im(dir)==0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir;
      N += 1;
      si N==n+1 alors break fsi;
      si nombre alors
       si isprime(N) alors  L.append(couleur(legende(z,N),1));
       sinon L.append(couleur(legende(z,N),0));fsi;
      sinon
        si isprime(N) alors L.append(couleur(carre(z,z+1),rouge+rempli));
      fsi;
     fsi;
    fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
  return L;
ffonction:;

exeonload
axes=0;spirale2prem(56,1) exe

axes=0;spirale2prem(100,0) exe

axes=0;spirale2prem(15000) exe

3.3  La spirale des nombres premiers et des premiers jumeaux

On peut modifer ce programme pour avoir les nombres premiers de 1 à $n$ répéré par des carrés rouge ou bleu pour les nombres premiers jumeaux. On remplit la spirale au fur et à mesure.

fonction spiralejum(n)
  local L,j,k,N,z,dir,Np,zp;
  N:=1; z:=0; L:=[];
  dir:=1;
  //L.append(couleur(carre(z,z+1),rouge+rempli)); 
  k:=0;Np:=2;zp:=1;
  tantque N<n faire
    si im(dir)=0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir; 
      N += 1;
      si isprime(N) alors 
        si N==Np+2 alors 
        L.append(couleur(carre(zp,zp+1),bleu+rempli));
        L.append(couleur(carre(z,z+1),bleu+rempli)); 
        sinon 
         L.append(couleur(carre(z,z+1),rouge+rempli)); 
        fsi;
        zp:=z;Np:=N;
       fsi;       
     fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
return L;
ffonction:;

exeonload
axes=0;spiralejum(100) exe

axes=0;spiralejum(150) exe

axes=0;spiralejum(15000) exe

3.4  La spirale des nombres premiers et des premiers jumeaux débutant à $n0$

On remplit, au fur et à mesure, la spirale débutant à $n0$ par des carrés bleu pour les nombres premiers jumeaux et rouge pour les nombres premiers non jumeaux.

fonction spiralejumn0(n0,n)
  local L,j,k,N,z,dir,Np,zp;
  N:=n0; z:=0; L:=[];
  dir:=1;
  //L.append(couleur(carre(z,z+1),rouge+rempli)); 
  k:=0;Np:=2;zp:=1;
  tantque N<n faire
    si im(dir)=0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir; 
      N += 1;
      si isprime(N) alors 
        si N==Np+2 alors 
        L.append(couleur(carre(zp,zp+1),bleu+rempli));
        L.append(couleur(carre(z,z+1),bleu+rempli)); 
        sinon 
         L.append(couleur(carre(z,z+1),rouge+rempli)); 
        fsi;
        zp:=z;Np:=N;
       fsi;       
     fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
return L;
ffonction:;

exeonload
axes=0;spiralejumn0(101,300) exe

axes=0;spiralejumn0(41,2000) exe

axes=0;spiralejumn0(15001,30000) exe

4  Le programme des nombres premiers écrits en spirale avec leurs affixes

4.1  L’affixe des nombres entiers $n \geq 1$ écrits selon une spirale: faffixe

Soit $faffixe$ la fonction qui à un entier $n\geq 1$ renvoie son affixe dans la spirale, en prenant comme repère orthonormé ($faffixe(1),\overrightarrow{faffixe(1),faffixe(2)},\overrightarrow{faffixe(1),faffixe(4)}$).
On a donc :
$faffixe(1)=0$, $faffixe(2)=1$, $faffixe(3)=1+i$, $faffixe(4)=i$, $faffixe(5)=-1+i$,....,$faffixe(9)=1-i$,...
On remarque :

1. lorsque la spirale forme un carré (par exemple $1,2,3,4$ ou $1,2,3,4,5,6,7,8,9$) les carrés se terminant par $(2p)^2$ ont pour affixe $-p+1+p*i$ et
   les carrés se terminant par $(2p+1)^2$ ont pour affixe $p-p*i$.
   Donc :
   si $a$ est pair alors $faffixe(a^2)=(-a+2+a*i)/2$ et
   si $a$ est impair alors $faffixe(a^2)=(a-1+(-a+1)*i)/2$.
2. si $a$ est pair et si $a^2+1\leq n=a^2+k\leq a^2+a+1$, on a :
   re($faffixe(n)$)=re($faffixe(a^2)$)-$1=(-a+2)/2-1=-a/2$
   im($faffixe(n)$)=im($faffixe(a^2)$)-$k+1=a/2-k+1$.
   Donc :
   si $a^2=(2p)^2<n=a^2+k\leq a^2+a+1=(2p)^2+2p+1$ alors
   $faffixe(n)=faffixe(a^2+k)=(-a+a*i)/2-(k-1)*i$ et $faffixe(a^2+a+1)=-a/2+a*i/2$
3. si $a$ est pair et si $a^2+a+1=(2p)^2+2p+1<n=a^2+a+1+j< (2p)^2+4p+1=(2*p+1)^2$ on a :
   $n=a^2+k$ avec $k=a+1+j$ et
   re($faffixe(n)$)=re($faffixe(a^2+a+1)$)+$j=-a/2+k-a-1$
   im($faffixe(n)$)=im($faffixe(a^2)$)=$-a/2$.
   Donc :
   si $a^2+a+1=(2p)^2+2p+1<n=a^2+a+1+j\leq (2p)^2+4p+1=(2*p+1)^2$ on a :
   $faffixe(n)=faffixe(a^2+k)=(-a-a*i)/2+k-a-1$
4. si $a$ est impair et si $a^2=(2p+1)^2<n=a^2+k<a^2+a+1=(2p+1)^2+2p+2$ alors
   re($faffixe(n)$)=re($faffixe(a^2)$)+$1=(a-1)/2+1=(a+1)/2$
   im($faffixe(n)$)=im($faffixe(a^2)$)-$k-1=(-a+1)/2+k-1$.
   donc
   $faffixe(n)=faffixe(a^2+k)=(a+1)/2+i*(-a+1)/2+i*(k-1)$ et donc
   $faffixe(a^2+a+1)=(a+1)/2+i*(-a+1)/2+i*a=(a+1)/2+i*(a+1)/2$
5. si $a$ est impair et si $a^2+a+1=(2p+1)^2+2p+2<n=a^2+a+1+j<a^2+2a+1=(2p+2)^2$ on a :
   $n=a^2+k$ avec $k=a+1+j$ et
   re($faffixe(n)$)=re($faffixe(a^2+a+1)$)-$j=(a+1)/2-k+a+1=-a/2-a*i/2$
   im($faffixe(n)$)=im($faffixe(a^2+a+1)$)=$(a+1)/2$.
   donc
   $faffixe(n)=faffixe(a^2+k)=(a+1)/2+a+-k+1+i*(a+1)/2$

On écrit la fonction faffixe :

fonction faffixe(n)
  local a,k,p,q,j;
  si n<=0 or type(n)!=integer alors 
     return "bad argument type"; 
  fsi;
  a:=floor(sqrt(n));k:=n-a^2;
  si est_impair(a) alors
    si k==0 alors return (a-1+i*(-a+1))/2; fsi;
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k==0 alors return (-a+2+i*a)/2; fsi;
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 

exeonload
faffixe(31),faffixe(37),faffixe(41),faffixe(43) exe

4.2  La spirale des nombres premiers $\geq 1$ avec la fonction faffixe

En utilisant la fonction faffixe précédente, on écrit les nombres entiers de 1 à $n$, selon une spirale, en écrivant les nombres premiers en rouge.
On tape :

fonction spirale(n)
  local k,L,b;
  L:=NULL;
   pour k de 1 jusque n faire
    b:=faffixe(k);
    //L:=L,carre(b,b+1);
    si est_premier(k) alors  
      L:=L,affichage(legende(b,k),1);
    sinon 
      L:=L,legende(b,k) ;fsi;
  fpour;
  return L;
ffonction:;

exeonload
axes=0;spirale(56) exe

axes=0;gl_x=-6..6;spirale(81) exe

5  La spirale des nombres premiers $n \geq n0$ avec la fonction faffixe

On peut modifier légèrement ce programme pour écrire les nombres entiers de $n0$ à $n$ en écrivant les nombres premiers en rouge.

fonction spiralen0(n0,n)
  local k,L,b;
  L:=NULL;
   pour k de n0 jusque n faire
    b:=faffixe(k-n0+1);
    //L:=L,carre(b,b+1);
    si est_premier(k) alors  
      L:=L,affichage(legende(b,k),1);
    sinon 
      L:=L,legende(b,k) ;fsi;
  fpour;
  return L;
ffonction:;

exeonload
axes=0;spiralen0(31,99) exe

axes=0;spiralen0(41,99) exe

5.1  Programme n’affichant que les nombres premiers selon un carré rouge

Le programme spiralprem(n) affiche, selon un carré rouge, les nombres premiers inférieur ou égaux à n selon une spirale.

fonction spiralprem(n)
  local k,L;
  L:=NULL;
   pour k de 1 jusque n faire
    si est_premier(k) alors  
      L:=L,affichage(carre(faffixe(k),faffixe(k)+1),1+rempli);
   fsi;
  fpour;
  return L;
 ffonction:; 

exeonload
axes=0;spiralprem(100) exe

axes=0;spiralprem(15000) exe

5.2  Exercice : saffixe une amélioration de faffixe

Dans le programme spiralprem précédent on ne calcule faffixe(n) que lorsque n est premier. Donc, puisque un carré parfait n’est pas un nombre premier, on peut commenter plusieurs instructions :

fonction faffixe0(n)
  local a,k,p,q,j;
  //si n<=0 or type(n)!=integer alors  return "bad argument type"; fsi;
  a:=floor(sqrt(n));
  k:=n-a^2;
  si est_impair(a) alors
    //si k==0 alors return (a-1+i*(-a+1))/2; fsi;
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    //si k==0 alors return (-a+2+i*a)/2; fsi;
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 

exeonload
Mais alors faffixe1(a^2) n’est pas correct !
faffixe(81),faffixe0(81),faffixe(82),faffixe0(82) exe

Exercice
Changer la première instruction du programme faffixe0(n) pour obtenir la fonction saffixe(n) qui renvoie les affixes de tous les entiers n qui sont strictement positifs.
Correction
Pour faire l’algorithme de faffixe on a repéré les carrés (1,4,9,.. i.e. les croix rouges sur l’illustration suivante) et on a calculé l’affixe de n en fonction de a= floor(sqrt(n)) et cela nous a obligé à traité l’affixe des carrés à part (cf tracer1).
Mais ce n’est pas le cas si on choisit de calculer l’affixe de n en fonction de a= ceil(sqrt(n))-1 (cf tracer2).
gl_ortho=1,spir(-3+2*i),tracer1(-3+2*i),spir(-3-3*i),tracer2(-3-3*i) exe
On tape :

fonction saffixe(n)
  local a,k,p,q,j;
  a:=ceil(sqrt(n))-1;
  k:=n-a^2;
  si est_impair(a) alors
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
 

exeonload

saffixe(4),saffixe(25),saffixe(36),faffixe(4),faffixe(25),faffixe(36) exe

6  La spirale des carrés rouge représentant les nombres premiers

fonction spiraleprem(n)
  local k,L,b;
  L:=NULL;
   pour k de 1 jusque n faire
    b:=saffixe(k);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
     fsi;
  fpour;
  return L;
ffonction :;
fonction spiralepremn0(n0,n)
  local k,L,b;
  L:=NULL;
   pour k de n0 jusque n faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
     fsi;
  fpour;
  return L;
ffonction:;

exeonload
axes=0;spiraleprem(15000) exe

axes=0;spiralepremn0(101,3000) exe

7  Programmes qui ne teste que les nombres $6k-1$ et $6k+1$

En effet les nombres premiers strictement supérieur à 3 sont soit de la forme : $6k-1$ ou $6k+1$ pour $k$ entier strictement positif $6k$ est divisible par 6, $6k+2$ est divisible par 2, $6k+3$ est divisible par 3, $6k+4$ est divisible par 2. donc seuls $6k +1$ et $6k+5=6*(k+1)-1$ peuvent être premiers

7.1  La spirale des nombres premiers débutant à 1 ou à $n0$

Lorsqu’on débute la spirale par $n0$, on peut avoir un programme plus simple si on suppose que $n0$ est un mulitple de 6.
Comme on progresse de 6 en 6 en peut avoir une spirale qui va au delà de $n$.

fonction spiraleprem6(n)
  local k,L,a,b,z1,r;
  L:=NULL;
  r:=irem(n,6);
 // pour 2 et 3
  L:=L,affichage(carre(1,2),1+rempli);
  L:=L,affichage(carre(1+i,2+i),1+rempli);
  pour k de 6 jusque n+6-r pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
      si  a==1  alors
        z1:=saffixe(k-1)
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
      si b==1  alors
        z1:=saffixe(k-1);
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
    fpour;
  return L;
ffonction:;

fonction spiraleprem6n0(n0,n)
  local k,L,a,b,r,z1,r0,n1;
  L:=NULL;
  r0:=irem(n0,6);
  r:=irem(n,6);
  //n+(6-r)=6*q+r0+(6-r0)=6*(q+1)
   pour k de n0 jusque n0+6-r faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
    fsi;
  fpour;
  n1:=n0+6-r0; 
  pour k de n1 jusque n+6-r pas 6 faire
      (a,b):=(est_premier(k-1),est_premier(k+1));
      si  a==1 alors 
        z1:=saffixe(k-n0);
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
      si  b==1 alors    
        z1:=saffixe(k+2-n0)
        L:=L,affichage(carre(z1,z1+1),1+rempli);  
      fsi;
  fpour;
  return L;
ffonction:; 

exeonload
axes=0;spiraleprem6(2000) exe

axes=0;spiraleprem6(101) exe

axes=0;spiraleprem6n0(41,5000) exe

7.2  La spirale des nombres premiers et les nombres premiers jumeaux débutant à 1 ou à $n0$

Les nombres premiers jumeaux sont 2 nombres premiers dont la différence vaut 2.
On ne sait toujours pas si il y en a une infinité de nombres premiers jumeaux.
On rajoute la possibilité de placer la spirale au point d’affixe z0

fonction spiralejumeaux6(z0,n)
  local k,L,a,b,z1,z2 ;
  L:=NULL;
 // pour 2 et 3
  L:=L,affichage(z0+carre(1,2),1+rempli);
  L:=L,affichage(z0+carre(1+i,2+i),4+rempli);
  pour k de 6 jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-1);z2:=saffixe(k+1)
    si [a,b]==[1,1] alors
      L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
      L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
    sinon 
      si  a==1  alors
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
      sinon
          L:=L,affichage(z0+carre(z2,z2+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;

fonction spiralejumeaux6n0(z0,n0,n,nombre=0)
  local k,L,a,b,z1,z2,n1,r0,r;
  L:=NULL;
  r0:=irem(n0,6);r:=irem(n,6);
  si n0<=5 alors 
    pour k de n0 jusque 2 faire
      si est_premier (k) alors 
        z1:=saffixe(k-n0+1);
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
         si nombre alors L:=L,affichage(legende(z0+z1,k),0);fsi;
      fsi;
    fpour;
     z1:=saffixe(3-n0+1);
     L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
    si nombre alors L:=L,affichage(legende(z0+z1,3),0);fsi;
 sinon
   pour k de n0 jusque n0+6-r0 faire
      si isprime(k) alors print(k);
         z1:=saffixe(k-n0+1);
         L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
          si nombre alors L:=L,affichage(legende(z0+z1,k),0);fsi;
      fsi;
   fpour;
 fsi;
   n1:=n0+6-r0;  
 pour k de n1 jusque n+6-r pas 6 faire 
   (a,b):=(est_premier(k-1),est_premier(k+1));
    si a+b!=0 alors z1:=saffixe(k-n0);z2:=saffixe(k+2-n0);
      si [a,b]==[1,1] alors
         L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
         L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
         si nombre alors 
            L:=L,affichage(legende(z0+z1,k-1),0);
            L:=L,affichage(legende(z0+z2,k+1),0);4
         fsi;
      sinon 
         si  a==1 alors 
           L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
            si nombre alors L:=L,affichage(legende(z0+z1,k-1),0);fsi
         sinon 
           L:=L,affichage(z0+carre(z2,z2+1),1+rempli);
            si nombre alors L:=L,affichage(legende(z0+z2,k+1),0);fsi;
         fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;

exeonload
axes=0;spiralejumeaux6(0,15000),spiralejumeaux6n0(130,15000,30000) exe

axes=0;spiralejumeaux6n0(0,30011,36000);droite(y=x,affichage=3) exe

axes=0;spiralejumeaux6n0(0,17,6000) exe

axes=0;spiralejumeaux6n0(0,41,6000) exe

8  Les programmes utilisés

fonction tabprem(z0,n)
  local j,k,L,a;
  L:=NULL;a:=floor(sqrt(n));
  pour j de 0 jusque a-1 faire
    pour k de 1 jusque a faire
       si isprime(j*a+k) alors 
         L:=L,affichage(carre(z0+k+j*i,z0+k+j*i+1),1+rempli);
         // L:=L,legende(k+j*i,j*a+k); 
       fsi;
    fpour;
  fpour;
  return L;
ffonction:;
fonction tabprem6(z0,n)
  local j,k,L,a;
  L:=NULL;
  a:=iquo(n,6);
  pour j de 0 jusque a-1 faire
    pour k de 1 jusque 6 faire
      //L:=L,carre(z0-1+k+j*i,z0+k+1+j*i);
      si isprime(j*6+k) alors 
      L:=L,affichage(legende(z0-1+k+j*i,j*6+k),1);
      sinon 
      L:=L,legende(z0-1+k+j*i,j*6+k) ;       
    fsi;
 fpour;
 fpour;
pour j de 1 jusque n-6*a faire
si isprime(6*a+j) alors 
      L:=L,affichage(legende(z0-1+j+a*i,6*a+j),1);
      sinon 
      L:=L,legende(z0-1+j+a*i,6*a+j) ;  
fsi;
fpour;
 return L;
ffonction :;
fonction spir(z0)
  local L;
  L:=NULL;
  L:=L,z0+segment(1+i,i);
  L:=L,z0+segment(0,i);
  L:=L,z0+segment(0,2);
  L:=L,z0+segment(2,2+2*i);
  L:=L,z0+segment(-1+2*i,2+2*i);
  L:=L,z0+segment(-1+2*i,-1-i);
  L:=L,z0+segment(3-i,-1-i);
  L:=L,z0+segment(3-i,3+3*i);
  L:=L,z0+segment(-2+3*i,3+3*i);
  return affichage(L,epaisseur_ligne_5);
ffonction :;
fonction tracer1(z0)
 local L;
L:=NULL; 
L:=L,affichage(z0+point(0.5+i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(0.5+i*1.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(1.5-i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(-0.5+i*2.5),1+epaisseur_point_5);
L:=L,affichage(z0+segment(0.5+0.5*i,1.5+0.5*i),1);
L:=L,affichage(z0+segment(1.5+0.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(0.5+1.5*i,-0.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,-0.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,0.5-0.5*i),1);
L:=L,affichage(z0+segment(2.5-0.5*i,2.5+2.5*i),1);
L:=L,affichage(z0+segment(0.5+2.5*i,2.5+2.5*i),1);  
L:=L,affichage(z0+segment(1.5-0.5*i,2.5-0.5*i),1); 
return L;  
ffonction:;
fonction tracer2(z0)
 local L;
L:=NULL; 
 L:=L,affichage(z0+point(0.5+i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(0.5+i*1.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(1.5-i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(-0.5+i*2.5),1+epaisseur_point_5);
L:=L,affichage(z0+segment(1.5+0.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(0.5+1.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5+1.5*i,-0.5-0.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,1.5-0.5*i),1);
L:=L,affichage(z0+segment(2.5-0.5*i,2.5+2.5*i),1);
L:=L,affichage(z0+segment(-0.5+2.5*i,2.5+2.5*i),1);
return L;  
ffonction:;

exeonload

Clone Clear + - ->   Restart Exec. all