\documentclass[XUPS,XML,SOM,Unicode,francais,NoFloatCountersInSection]{cedram}
\setcounter{tocdepth}{2}
%\XUPScorrections
\usepackage{graphicx}
\usepackage{alltt}
\graphicspath{{xups01-02b_figures}}

\newcommand{\Smaller}{\smaller\smaller}

\newtheoremstyle{remarqu*}{}{}{}{-\parindent}{\sf}{.\hspace*{\leftskip}}{\hbox{}\newline}{}
\theoremstyle{remarqu*}\newtheorem*{remi*}{Remarque}


\newenvironment{rem*}{\begin{remarque*}}{\end{remarque*}}

\begin{document}
\frontmatter

\title{Programme et galerie}
\author[\initial{J.-R.} \lastname{Geoffroy}]{\firstname{Jean-René} \lastname{Geoffroy}}
\address{Laboratoire de Mathématiques,
UMR 8628 du CNRS, Bât 425, Université Paris-Sud,
91405 Orsay, France}

\thanks{Journées X-UPS 2001. Pavages. Éditions de l'École polytechnique, 2001}

\maketitle
\mainmatter

%\vspace*{-.5cm}
On présente ici un programme {\sf\bfseries Maple} permettant de représenter les tuiles des pavages
autosimilaires. On indiquera par un symbole {\tt //} les coupures de lignes dues à la mise en page.


Il s'agit essentiellement de calculer des développements en base $\beta$, de décrire une partie de
l'ensemble des développements faiblement propres puis de colorer leurs projections sur le plan selon
la partie fractionnaire des $\beta$-représentations.


On utilise la proposition 2.3 pour caractériser les développements faiblement propres.


Du point de vue informatique, on dispose de trois paramètres dans cette construction :\\
$\circ$\quad la base $\beta$ de représentation (entièrement déterminée par son polynôme minimal)\\
$\circ$\quad les entiers $p$ et $q$ correspondant à la taille des développements manipulés :\\
$p$ indique la taille des $\beta$-parties entières et $q$ celle des $\beta$-parties fractionnaires.

\begin{rem*}
La valeur de $q$ (la taille de la partie fractionnaire) influe sur le nombre de tuiles du pavage qui sont
représentées (ce nombre est le cardinal des développements faiblement propres de taille $q$).\\
La valeur de $p$ ne modifie pas le nombre de tuiles, mais, tout comme~$q$, le nombre de représentations
envisagées : on peut le voir comme un paramètre de \og densité visuelle\fg du dessin.
\end{rem*}

On commence par remettre à zéro la feuille de calcul :

\pagebreak[2]
\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
{\slshape{}#remise à zéro de la feuille}
> restart : 
\end{alltt}\egroup
\par\medskip\hrule\par\medskip

La procédure {\tt devfaible} permet de calculer le développement faiblement propre d'un
réel positif {\tt x} dans une base quelconque {\tt b} avec {\tt n} chiffres après la virgule.\\
La valeur retournée est une liste dont le format est le suivant :

\begin{center}$\mathtt{[p, c_1, \ldots, c_k]}$\end{center}

Le premier élément indique la position de la virgule : on a $k=p+n$ et le réel {\tt x}
s'écrit $\mathtt{x=c_1\ldots{}c_p\text{\larger ,}c_{p+1}\ldots{}c_k}$ en base {\tt b}.\medskip\\
Il est nécessaire de réaliser les calculs avec une grande précision pour éviter les erreurs d'arrondi
lors de l'utilisation des parties entières.\\
On utilise la formule {\tt floor(y)-floor(1-frac(y))} pour obtenir une \og partie entière stricte\fg : lorsque le paramètre
{\tt x} possède une représentation finie, on choisit sa représentation infinie.
\enlargethispage{.5cm}

\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
>{\larger\sf\bfseries devfaible} := {\larger{}proc}(b::realcons,x::realcons,n::integer)
   {\larger{}local} y,i,dev,digits_Backup ;
   
   {\slshape{}#sauvegarde du paramètre de précision}
      digits_Backup := Digits ;
      Digits := 50 + n * 100 ;
            
      if not(type(evalf(x),positive)) then
        {\larger{}ERROR}("{\sffamily{}Le paramètre x doit \^etre positif}") ;
      fi ; 
      
      if not(type(evalf(b),positive)) then
        {\larger{}ERROR}("{\sffamily{}Le paramètre x doit \^etre positif}") ;
      fi ; 

      i := floor(evalf(ln(x)/ln(b))) ;
      dev := [i+1] ;
      y := x * (b^(-i)) ;
      {\larger{}for} i from 1 to n+max(0,dev[1]){\larger do}
         dev := [op(dev),floor(y)-floor(1-frac(y))] ;
         y := b * (y-dev[-1]) ;
      {\larger{}od ;}

   {\slshape{}#restauration du paramètre de précision}
      Digits := digits_Backup ;
      
   {\larger RETURN}(dev) ;
  {\larger{}end} :
\end{alltt}\egroup

Par exemple
\bgroup\Smaller\begin{alltt}
> devfaible(10,1,5) ;\begin{center}{\sl[1, 0, 9, 9, 9, 9, 9]}\end{center}
\end{alltt}\egroup

\par\medskip\hrule\par\medskip

La procédure {\tt calcule\underline{\hspace*{.5em}}pisot} permet de calculer le nombre de Pisot associé
à un polynôme :\\
On commence par vérifier que le polynôme {\tt p} en la variable {\tt x} passée en paramètre définit
bien une unité de Pisot (si ce n'est pas le cas, une erreur est générée pour avertir l'utilisateur),
puis on renvoie un couple de valeurs $\mathtt{[\beta,\gamma]}$ correspondant aux valeurs numériques du nombre
de Pisot et de son conjugué de Galois.\\
Comme on manipule des polynômes à coefficients réels, pour obtenir une unité de Pisot, il doit y avoir
exactement une racine réelle (et plus grande que $1$).

\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
>{\larger\sf\bfseries calcule_pisot} := {\larger{}proc}(p::polynom,x::name)
      {\larger{}local} racines,pisot,expan :
  
      if not(lcoeff(p,x)=1) then
          {\larger{}ERROR}(sprintf("{\sffamily{}Le polynôme %a n'est pas unitaire !}",p)) :
      fi :

      if not(type(p,polynom(integer,x))) then
          {\larger{}ERROR}(sprintf("{\sffamily{}Le polynôme %a n'est pas à coefficients\hfill//
                         entiers !}",p)) :
      fi :
 
      if not(abs(tcoeff(p,x))=1) then
          {\larger{}ERROR}(sprintf("{\sffamily{}Le terme constant de %a n'est pas une\hfill//
                         unité !}",p)) :
      fi :
  
      racines := [fsolve(p=0,x,complex,fulldigits)] ;
      pisot := select(z->type(z,realcons),racines) ;
      pisot := select(x->evalb(x>1),pisot) ;
      
      if nops(pisot)>1 then
          {\larger{}ERROR}(sprintf("{\sffamily{}Le polynôme %a possède trop de racines\hfill//
                          réelles{\tt >}1 :\(\backslash\)n %a",p,mr)}) :
      fi :

      if nops(pisot)=0 then
          {\larger{}ERROR}(sprintf("{\sffamily{}Le polynôme %a ne possède pas de racine\hfill//
                         réelle{\tt >} 1 !",p)}) :
      fi :

      expan := select(z->evalb(Im(z)>0),racines) ;
  
      {\larger{}RETURN}([op(pisot),op(expan)]) ;
 {\larger{}end}:
\end{alltt}\egroup
\par\medskip\hrule\par\medskip

Exemple d'appel :\enlargethispage{\baselineskip}%
\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
> calcule_pisot(X^3-X-1,X) ;\begin{center}{\sl[1.324717957, -.6623589786+.5622795121*I]}\end{center}
\end{alltt}\egroup
\par\medskip\par\hrule\medskip
\begin{center}
\begin{minipage}{90mm}
\begin{center}
\noindent\includegraphics[width=70mm]{Pisots10}
\end{center}
{\small\sl Ce tableau représente en abscisse les unités de Pisot positives de degré $3$ dont le polynôme minimal
a tous ses coefficients inférieurs en valeur absolue au nombre porté en ordonnée.}
\end{minipage}
\end{center}


\medskip
Pour réaliser la figure 2.3, on a simplement fait appel à cette procédure (en filtrant les erreurs), par exemple
de la fa\c{c}on suivante :

\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
> Liste_Pisot:=[] :
  {\larger{}for} cmax from 1 to 10 do
     {\larger{}for} c1 from -cmax to cmax do
        {\larger{}for} c2 from -cmax to cmax do
           {\larger{}for} c3 from 0 to 1 do 
              pisot := [] ;
              pisot := {\larger{}traperror}(\hfill//
                     calcule_pisot(X^3+c2*X^2+c1*X+(-1)^c3,X)) ;
              if nops(pisot)>1 then 
             Liste_Pisot := [op(Liste_Pisot), [pisot[1],cmax]] ;
              fi ;
           {\larger{}od} ;
        {\larger{}od} ;
     {\larger{}od} ;
  {\larger{}od} ; 
 PLOT(POINTS(op(Liste_Pisot),COLOR(RGB,1,0,0),SYMBOL(CROSS)),\hfill//
                          AXESSTYLE(BOX),SCALING(CONSTRAINED)) ;
\end{alltt}\egroup
\par\medskip\hrule\par\medskip

On vérifie de cette fa\c{c}on qu'il existe 89 nombres de Pisot obtenus comme racines de polynômes dont les coefficients
sont inférieurs en valeur absolue à~10.\\
En modifiant un peu cette boucle, on peut également représenter l'ensemble des constantes d'expansion associées
(et leurs inverses) :\smallskip\noindent

\begin{figure}[htb]
\begin{center}\hfill
\begin{minipage}{50mm}\noindent
\begin{center}
\noindent\includegraphics[width=40mm]{PExp15}
\end{center}

{\small\sl Conjugués de Galois des unités de Pisot de degré $3$ obtenues comme racines de polynômes de coefficients majorés
en valeur absolue par $15$.}
\end{minipage}\hfill
\begin{minipage}{50mm}\noindent
\begin{center}
\noindent\includegraphics[width=40mm]{PExpIv15}\smallskip
\end{center}

{\small\sl Constantes d'expansion pour les polynômes de coefficients majorés en valeur absolue par $15$.}
\end{minipage}\hfill\medskip
\end{center}
\end{figure}

Les deux procédures suivantes permettent de tester si un développement donné est faiblement propre pour la
base {\tt b}.\enlargethispage{\baselineskip}

\par\medskip\hrule\par\medskip\noindent
%\begin{minipage}{\textwidth}
\noindent
\bgroup\Smaller\begin{alltt}
> {\larger{}lex_large_list} := {\larger{}proc}(l1::list,l2::list,d::integer)
    {\larger{}local} m,i ;

  m := min(nops(l1)-d,nops(l2))-1 ;
 {\larger{}for} i from 1 to m {\larger{}while} l1[i+d]=l2[i] {\larger{}do} : {\larger{}od} :

 {\larger{}RETURN}(evalb(l1[i+d]<=l2[i]))
 {\larger{}end} :
> {\larger{}rep_stricte} := {\larger{}proc}(l1::list,b::numeric)
    {\larger{}local} d,carry_seq ;
  
carry_seq := subsop(1=NULL,2=NULL,devfaible(b,1,nops(l1))) ;
{\larger{}for} d from 0 to (nops(l1)-2) {\larger{}while} lex_large_list(l1,carry_seq,d) {\larger{}do}: {\larger{}od}:
 
  {\larger{}RETURN}(lex_large_list(l1,carry_seq,d)) ; 
 end :
\end{alltt}\egroup

\noindent
Exemple d'appel :
\bgroup\Smaller\begin{alltt}
> rep_stricte([1,0,0,0,1,0,0,1],1.324717957) ;\begin{center}{\sl{}false}\end{center}
> rep_stricte([1,0,0,0,0,0,1,0],1.324717957) ;\begin{center}{\sl{}true}\end{center}
\end{alltt}\egroup

\par\medskip\hrule\par\medskip\noindent
La routine {\tt pavage} est le moteur principal de l'affichage des tuiles. Il s'agit d'un parcours des développements
faiblement propres réalisé dans le sens décroissant ; on utilise les propriétés suivantes :\\
Soit un $\beta$-développement faiblement propre, voici la méthode pour obtenir le $\beta$-développement faiblement propre
immédiatement inférieur :\\
$\circ$\quad Si on décrémente le dernier coefficient non nul de la suite, tous les translatés de la représentation
sont diminués ou inchangés : elle reste faiblement propre.\\
$\circ$\quad Si on doit poser une retenue, il suffit de remplacer le translaté correspondant par la suite de retenue
(tronquée de manière adéquate) pour que la représentation vérifie encore la proposition 2.3.\\
De cette fa\c{c}on, il n'est pas nécessaire de tester qu'une représentation est faiblement propre à chaque étape.\\
Les paramètres de {\tt pavage} sont, comme on l'a indiqué au début du paragraphe : {\tt R} le polynôme minimal en {\tt X}
définissant la base $\beta$, et~{\tt p},~{\tt q} définissant la taille des représentations manipulées.\\
Avant de présenter la routine {\tt pavage} proprement dite, on commence par mettre en \oe{}uvre la technique de parcours pour
déterminer le nombre de développements faiblement propres de longueur donnée :
\par\medskip\hrule\par\medskip\smallskip\noindent
%\begin{minipage}{\textwidth}
\noindent
\bgroup\Smaller\begin{alltt}
> {\larger{}ntuile} := {\larger{}proc}(R::polynom,X::name,q::integer)
 
  {\larger{}local} rep,lrep,b,pisot,i,j,carry_seq :
  
  pisot := calcule_pisot(R,X) ;
  b := op(1,pisot) ;
  carry_seq := [op(3..-1,devfaible(b,1,q))] ;
  rep := carry_seq ;
  j := nops(rep) :
  lrep := [] :
\end{alltt}\egroup

\noindent
\bgroup\Smaller\begin{alltt}
  {\larger{}while}(j>0) {\larger{}do}
   lrep:=[op(lrep),rep] ;
    {\larger{}if} rep[j]>0 then
      rep:=subsop(j=rep[j]-1,rep) :
    {\larger{}else}
      {\slshape{}# on insère la suite de retenue}
      {\larger{}for} i from j to 1 by -1 while (rep[i]=0) {\larger{}do}: {\larger{}od}:
      {\larger{}if} (i=0) then
        j:=0 ;
      {\larger{}else}
        rep:=subsop(i=rep[i]-1,rep) :
        {\larger{}for} j from (i+1) to q {\larger{}do}
          rep := subsop(j=carry_seq[j-i],rep):
        {\larger{}od}:
        j:=nops(rep) :
      {\larger{}fi}:
    {\larger{}fi}:
  {\larger{}od}:
    
  print(q,nops(lrep)) ;
  print(lrep) ;
 {\larger{}end}:
\end{alltt}\egroup
\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
>{\larger\sf\bfseries pavage} := {\larger{}proc}(R::polynom,X::name,p::integer,q::integer)
 
 {\larger{}global} dPoints, rep :
 {\larger{}local} b,lambda,pisot,i,j,k,pos,v,carry_seq,time_backup,\hfill//
          RPOL,LPOL,POL,SIMPX,SIMPY :
 
  pisot := calcule_pisot(R,X) ;
  b := op(1,pisot) ;
  lambda := op(2,pisot) ;
  carry_seq := [op(3..-1,devfaible(b,1,p+q))] ;
 
  SIMPX := sum('-coeff(R,X,k)*X^k','k'=0..degree(R,X)-1) :
  SIMPY := sum('-coeff(R,X,0)*coeff(R,X,k)*X^(k-1)', \hfill//
                                          'k'=1..degree(R,X)) :
 
 {\slshape{}# Informations de début de calcul}
  printf("Début du calcul des tuiles associées à %a\(\backslash\){}n\hfill//
      le coefficient d'expansion est %a\(\backslash\){}n\hfill//
      la suite de retenue : %a\(\backslash\){}n\hfill//
      la précision demandée est %a:%a\(\backslash\){}n",b,1/lambda,carry_seq,p,q) ;
  time_backup := time() ;
  
  {\slshape{}# Pour reprendre un calcul interrompu, il suffit de commenter}
  {\slshape{}# les deux lignes suivantes et d'invoquer à nouveau} pavage
  rep := carry_seq ;
  unassign(dPoints) ;
  
  j := nops(rep) :
  rep := subsop(j=rep[j]+1,rep) :
 
 {\larger{}while}(j>0) {\larger{}do}
   if rep[j]>0 then
     rep:=subsop(j=rep[j]-1,rep) :
   else
     {\slshape{}# on insère la suite de retenue}
     for i from j to 1 by -1 while (rep[i]=0) do : od:
     if (i=0) then
       j:=0 ;
       printf("\(\backslash\){}n Calcul terminé (après %a secondes)\(\backslash\){}n",\hfill//
                                       time()-time_backup) ;
     else
       rep:=subsop(i=rep[i]-1,rep) :
       for j from (i+1) to (p+q) do
         rep := subsop(j=carry_seq[j-i],rep):
       od:
       j:=nops(rep) :
     fi:
   fi:
   
   LPOL := sum('rep[p-i]*X^(i+1)','i'=0..p-1);
   RPOL := sum('rep[p+i]*Y^i','i'=1..q);
  
   {\slshape{}# on associe un chiffre à chaque tuile}
   v := subs(Y=ceil(b),RPOL) ;
   
   LPOL := simplify(LPOL,\(\lbrace{}\)X^3=SIMPX\(\rbrace\)): 
   RPOL := simplify(RPOL,\(\lbrace{}\)Y=SIMPY\(\rbrace\)):
   RPOL := simplify(RPOL,\(\lbrace{}\)X^3=SIMPX\(\rbrace\)) :
   
   POL := collect(LPOL+RPOL,X) ; 
   pos := subs(X=lambda,POL) ;
   
   if not(type(dPoints[v],list)) then
     printf("Création de la tuile %a\(\backslash\){}n",v) ;
     dPoints[v]:=[[Re(pos),Im(pos)]];
   else
     dPoints[v]:=[op(dPoints[v]),[Re(pos),Im(pos)]];
   fi ;
 {\larger{}od}:
 {\larger{}end}:
\end{alltt}\egroup
\par\medskip\hrule\medskip\par
Exemple d'appel :\enlargethispage{1.3\baselineskip}
\par\medskip\hrule\medskip\par
\bgroup\Smaller\begin{alltt}
> pavage(X^3-X-1,X,20,0) :
{\sl{}Début du calcul des tuiles associées à 1.324717957
        le coefficient d'expansion est -.8774388331-.7448617667*I
        la suite de retenue : [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
        la précision demandée est 20:0
Création de la tuile 0
Calcul terminé (après 5.277 secondes)}
\end{alltt}\egroup
\par\medskip\hrule\medskip\par

\begin{rem*}
Il est préférable d'invoquer cette procédure sur une ligne terminée par un caractère deux points : cela évite
d'afficher la liste des points calculés (qui peut \^etre très volumineuse).
\end{rem*}

Pour afficher le résultat du calcul, on peut utiliser une commande de la forme :
\par\medskip\hrule\medskip\par
\bgroup\Smaller\begin{alltt}
> c:=rand(255)/255 ;
> plotsetup(default) ;
> PLOT(op(map(x->POINTS(op(dPoints[x]),COLOR(RGB,c(),c(),c())\hfill//
         ,SYMBOL(CROSS)),select(x->evalb(nops(dPoints[x])>1),\hfill//
            [$0..2^10]))),AXESSTYLE(BOX),SCALING(CONSTRAINED)) ;
\end{alltt}\egroup
et pour stocker le résultat dans un fichier au format postscript, il suffit de remplacer la ligne
{\tt{}plotsetup(default)} par :
\bgroup\Smaller\begin{alltt}
plotsetup(ps,plotoutput=`Pisot`,plotoptions=`colour=rgb,\hfill//
                                       noborder,portrait`);
\end{alltt}\egroup
\smallskip

\hrule\medskip

Les temps de calcul sont très variables suivant la précision demandée : il est possible
d'afficher un résultat partiel après l'interruption d'un calcul, mais aussi de relancer un calcul stoppé
(en commentant les deux lignes indiquées dans {\tt{}pavage}).\\
La procédure {\tt{}pavage} stocke le résultat des calculs dans la variable global {\tt dPoints} : il s'agit
d'un tableau dont les éléments sont indexés par les entiers affichés lors du calcul ({\tt{}subs(Y=ceil(b),RPOL)}).
On peut donc afficher et manipuler chacune des tuiles indépendamment.\\
Par exemple, on va vérifier la nature fractale du pavage en superposant une tuile et son image par la multiplication par
$1/\lambda$ (inverse du conjugué de Galois de $\beta$) :
\par\medskip\hrule\par\medskip
\bgroup\Smaller\begin{alltt}
> pavage(X^3-X-1,X,20,0) ;
  lambda := op(2,calcule_pisot(X^3-X-1,X)) ;
  L := [Re(1/lambda),Im(1/lambda)] ;
  {\slshape{}# on redéfinit la mutliplication complexe...}
  f := (a,b)->[a[1]*b[1]-a[2]*b[2],a[1]*b[2]+a[2]*b[1]] ;
  {\slshape{}# on transforme la première tuile}
  d1Points:=map(z->f(z,L),dPoints[0]) :
  {\slshape{}# et on la superpose à son image (attention à l'ordre)}
  PLOT(POINTS(op(dPoints[0]),COLOR(RGB,1,0,0),SYMBOL(CROSS)),\hfill//
      POINTS(op(d1Points),COLOR(RGB,0,0,1),SYMBOL(CROSS)),\hfill//
      AXESSTYLE(BOX),SCALING(CONSTRAINED)) ;  
\end{alltt} \egroup
\par\medskip\hrule\pagebreak\par\medskip
On obtient (avec beaucoup moins de calculs) la figure de division des tuiles :\\
$\circ$\quad La partie rouge représente la \og tuile 0\fg, obtenue pour une précision $p:0$.\\
$\circ$\quad La partie bleue représente la portion de l'image de la \og tuile 0\fg par multiplication par $1/\lambda$
qui n'est pas recouverte par la \og tuile 0\fg.\smallskip
\begin{center}
\noindent\begin{minipage}{110mm}
\noindent\includegraphics[width=110mm]{Tcr}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=1.32471795724475\ldots$, racine du polynôme
$X^3-X-1$ (de suite de retenue $carry(\beta)=0.(10000)$).\\
Le pavage ne contient qu'un seul type de tuile à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip
\begin{center}
\begin{minipage}{70mm}
\noindent\includegraphics[width=70mm]{T1}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=2.3247179572447460260\ldots$, racine du polynôme
$X^3-3X^2+2X-1$ (de suite de retenue $carry(\beta)=0.20(1)$).\\
Le pavage est constitué de deux types de tuiles à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip
\begin{center}
\begin{minipage}{70mm}
\noindent\includegraphics[width=70mm]{T3}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=1.8392867552141611326\ldots$, racine du polynôme
$X^3-X^2-X-1$ (de suite de retenue $carry(\beta)=0.(110)$).\\
Le pavage est constitué de deux types de tuiles à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip
\begin{center}
\begin{minipage}{70mm}
\noindent\includegraphics[width=80mm]{T4}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=1.4655712318767680267\ldots$, racine du polynôme
$X^3-X^2-1$ (de suite de retenue $carry(\beta)=0.(100)$).\\
Le pavage est constitué de deux types de tuiles à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip\begin{center}
\begin{minipage}{70mm}
\noindent\includegraphics[width=70mm]{T5}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=2.2055694304005903117\ldots$, racine du polynôme
$X^3-2X^2-1$ (de suite de retenue $carry(\beta)=0.(200)$).\\
Le pavage est constitué de deux types de tuiles à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip
\begin{center}
\begin{minipage}{70mm}
\noindent\includegraphics[width=70mm]{T6}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=1.7548776662466927600\ldots$, racine du polynôme
$X^3-2X^2+X-1$ (de suite de retenue $carry(\beta)=0.(1100)$).\\
Le pavage est constitué de deux types de tuiles à rotations et homothéties près.
\end{minipage}
\end{center}
\par\bigskip
\begin{center}
\begin{minipage}{100mm}
\noindent\includegraphics[width=100mm]{T7}
\end{minipage}\medskip\\
\noindent\begin{minipage}{110mm}\Smaller
Motif du pavage associé à l'unité de Pisot $\beta=4.613470268\ldots$, racine du polynôme
$X^3-5X^2+2X-1$ (de suite de retenue $carry(\beta)=0.42(3)$).\\
Le pavage est constitué d'un seul type de tuile à rotations et homothéties près.
\end{minipage}
\end{center}
\par\medskip\hrule\par\medskip
On pourra trouver les fichiers source, des images ainsi que des liens vers d'autres pages concernant les fractales de Rauzy 
sur la page :
\begin{center}
\begin{minipage}{80mm}\noindent
\bgroup\Smaller\begin{alltt}http://www.math.u-psud.fr/~geoffroy/pisot\end{alltt}\egroup
\end{minipage}
\end{center}
\end{document}