\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{latexsym}
\usepackage{amssymb}
\usepackage{times}
\usepackage{ifpdf}
\usepackage{makeidx}
\usepackage{graphicx}
\ifpdf
 \usepackage[pdftex,colorlinks]{hyperref}
\else
 \usepackage[ps2pdf,breaklinks=true,colorlinks=true,linkcolor=red,citecolor=green]{hyperref}
 \fi

\newtheorem{rem}{Remark}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\newcommand{\Q}{{\mathbb{Q}}}
\newcommand{\atan}{{\mbox{atan}}}
%\newcommand{\faux}{$\square\;$}
%\newcommand{\vrai}{$\square\;$}
%\newtheorem{thm}{Theorem}
%\newtheorem{exo}{Exercice}[section]
\input{giac.tex}
\giacmathjax
\title{Octogones, pavage et rosaces}
\author{Ren\'ee De Graeve}
\date{2019}
\begin{document}
\begin{giacjshere}
\maketitle
\tableofcontents
\newpage
%cf octogonepc.xws octogonepr.xws octogone.xws
\section{Les octogones}
On veut tracer la figure suivante :\\
\giacinput{axes=0;octogone(0,0,5);}\\
Elle est  compos\'ee d'un octogone et d'un carr\'e
central. Les c\^ot\'es du carr\'e sont parall\`eles aux c\^ot\'es de l'octogone 
et ont la m\^eme longueur que ceux de l'octogone. Puis, on trace
les m\'edianes de l'octogone qui sont aussi les m\'edianes du carr\'e et les 
segments reliant les sommets du carr\'e aux c\^ot\'es de l'octogone en leur 
\'etant perpendiculaires.
\subsection{Exercice1}
Quelle est la longueur $l$ du c\^ot\'e d'un octogone r\'egulier inscrit dans un 
cercle de rayon $r$ ?\\
Comment peut-on construire le carr\'e \`a partir de l'octogone r\'egulier ?\\
Si on prend comme axes $Ox$ et $Oy$ des droites parall\`eles aux diagonales du 
carr\'e centr\'e en $O$, quelles sont les coordonn\'ees des sommets du 
carr\'e ? \\
{\bf R\'eponse1}\\
La longueur $l$ du c\^ot\'e d'un octogone r\'egulier inscrit dans un cercle
 de rayon $r$ est \'egale \`a $l=2r\sin(\frac{\pi}{8})$.\\
\giacinputbig{axes=0;O:=point(0);isopolygone(0,exp(i*pi/8),-8);A,B,C,D,E,F,G,H:=sommets(isopolygone(0,exp(i*pi/8),-8));segment(A,F),segment(B,E),segment(C,H),segment(D,G),segment(C,H)}
\`A partir de l'octogone r\'egulier $ABCDEFGH$, on construit les sommets $P$ 
(resp $Q,R,S$) du carr\'e  comme les intersections des segments $AF$ et $CH$ 
(resp $BE$ et $CH$, $BE$ et $DG$, $AF$ et $DG$).\\
\giacinputbig{axes=0;O:=point(0);octogone(0,0,5);A,B,C,D,E,F,G,H:=sommets(isopolygone(0,5*exp(i*pi/8),-8)):;P:=point(5*sqrt(2)*sin(pi/8)):;Q:=point(i*5*sqrt(2)*sin(pi/8));R:=point(-5*sqrt(2)*sin(pi/8));S:=point(-i*5*sqrt(2)*sin(pi/8));M:=point(5*cos(pi/8));N:=point(5*i*cos(pi/8));A:=A;B:=B;C:=C;F:=F;H:=H;I:=milieu(A,B);J:=milieu(P,Q);affichage([segment(A,F),segment(C,H),P],1);}\\
On note $I$ le milieu de $AB$ et $J$ le milieu de $PQ$.\\
On remarquera que les triangles $JOP$ et $MAP$ sont des triangles 
rectangles isoc\`eles \'egaux 
$$AM=IA=JP=\frac{l}{2}=r\sin(\frac{\pi}{8}) \ \mbox{et}\ AP=IJ=OP=l\frac{\sqrt{2}}{2}=r\sqrt{2}\sin(\frac{\pi}{8})$$
Les affixes des sommets du carr\'e sont :
$$r\sqrt{2}\sin(\frac{\pi}{8}),\ i r\sqrt{2}\sin(\frac{\pi}{8}),\ -r\sqrt{2}\sin(\frac{\pi}{8}),\ -i r\sqrt{2}\sin(\frac{\pi}{8})$$

\subsection{Exercice2}
On veut pouvoir emboiter les octogones, c'est pourquoi  les 
c\^ot\'es du carr\'e doivent avoir la m\^eme longueur que ceux de l'octogone.\\
Montrer que
$OM=r\cos(\frac{\pi}{8})$ et en d\'eduire que $OP=r(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})$).\\
En d\'eduire, la formule $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})=\sqrt{2}\sin(\frac{\pi}{8})$ et
le calcul des valeurs de $\sin(\frac{\pi}{8})$ et $\cos(\frac{\pi}{8})$.\\
{\bf R\'eponse2}\\
L'angle $\widehat{MOA}=\frac{\pi}{8}$ et $OA=r$ donc $OM=r\cos(\frac{\pi}{8})$.\\
On a montr\'e pr\'ec\'edemment que $PM=l/2=r\sin(\frac{\pi}{8})$ et
$0P=l\sqrt{2}/2=r\sqrt{2}\sin(\frac{\pi}{8})$ donc~:
$$OP=r\sqrt{2}\sin(\frac{\pi}{8})=OM-PM=r(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8}))$$
 Donc $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})=\sqrt{2}\sin(\frac{\pi}{8})$.\\ 
On a donc~:
$$\cos(\frac{\pi}{8})=\sin(\frac{\pi}{8})(1+\sqrt{2}) \ \mbox{ et } \ \cos(\frac{\pi}{8})^2=1-\sin(\frac{\pi}{8})^2$$
donc~:
$$1-\sin(\frac{\pi}{8})^2=\cos(\frac{\pi}{8})^2=(1+\sqrt{2})^2\sin(\frac{\pi}{8})^2=(3+2\sqrt{2})\sin(\frac{\pi}{8})^2$$
On obtient :
$$\sin(\frac{\pi}{8}))^2=\frac{2-\sqrt{2}}{4} \ \mbox{et} \  \cos(\frac{\pi}{8})^2=\frac{2+\sqrt{2}}{4}$$
Puisque $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})>0$ et $\sin(\frac{\pi}{8})>0$, on en d\'eduit :\\
$$\sin(\frac{\pi}{8})=\frac{\sqrt {2-\sqrt{2} }}{2} \ \mbox{ et }\  \cos(\frac{\pi}{8})=\frac{\sqrt{2+\sqrt{2} }}{2})$$
On a donc :\\
$$OJ=PM=AM=r\sin(\frac{\pi}{8}) \ \mbox{ et } \ JI=OP=r\sqrt{2}\sin(\frac{\pi}{8})$$
\subsection{Le programme}
Le programme {\tt octogone} trace l'octogone la figure d\'esir\'ee.\\
{\tt octogone} a pour coordonn\'ees l'affixe {\tt z} du centre de l'octogone,
 $t$ l'angle que fait une diagonale du carr\'e avec $Ox$
et $r$ le rayon du cercle circonscrit \`a l'octogone.
On utilise comme variable locale {\tt a} qui repr\'esente la longueur de 
$OP=r*(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8}))=r\sqrt{2} \sin(\frac{\pi}{8})$ i.e la moiti\'e de la longueur
de la diagonale du carr\'e.\\
En syntaxe Xcas~:
\begin{giaconload}
octogone(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,isopolygone(z,z+r*exp(i*pi/8+i*t),-8);
  L:=L,carre(z+a*exp(i*t),z+a*i*exp(i*t));
  L:=L,segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3); // $ genere une sequence
  L:=L,segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t));
  L:=L,segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t));
  return L;
}:;
\end{giaconload}
En syntaxe Python
\begin{giacprog}
def octogone(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(isopolygone(z,z+r*exp(i*pi/8+i*t),-8))
    L.append(carre(z+a*exp(i*t),z+a*i*exp(i*t)))
    L.append([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)])
    L.append(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)))
    L.append(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)))
    return L
\end{giacprog}
\giacinputbig{axes=0;octogone(0,0,5);octogone(10,pi/4,4),octogone(18,pi/8,3)}

\subsection{La ronde de 4 octogones autour d'un octogone central}
On veut tracer 4 octogones autour d'un octogone central.\\ 
\giacinputbig{axes=0;octogone(0,0,5);octogone(5*cos(pi/8)*(1+i),0,5);octogone(5*cos(pi/8)*(-1+i),0,5);octogone(5*cos(pi/8)*(-1-i),0,5);octogone(5*cos(pi/8)*(1-i),0,5);}\\
En syntaxe Xcas :\\
\begin{giaconload}
octogone5(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogone(z,t,r);
  pour k de 1 jusque 7 pas 2 faire 
    L:=L,octogone(z+r*sqrt(2)*cos(pi/8)*exp(i*t+i*k*pi/4),t,r);
  fpour;
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def octogone5(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(octogone(z,t,r))
    k=1
    while k<=7 :
        L.append(octogone(z+r*sqrt(2)*cos(pi/8)*exp(i*t+i*k*pi/4),t,r))
        k=k+2
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogone5(-18,0,4);octogone5(0,pi/8,4);octogone5(18,pi/4,4);}\\

\subsection{La ronde de 8 octogones autour d'un octogone central}
On veut tracer 8 octogones autour d'un octogone central.\\ 
\giacinputbig{axes=0;octogone(0,0,4),octogone((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(k*i*pi/2+i*pi/4),0,4)$(k=0..3),octogone(2*4*cos(pi/8)*exp(i*k*pi/2),0,4)$(k=0..3)}\\
En syntaxe Xcas :\\
\begin{giaconload}
octogone9(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogone(z,t,r);
  pour k de 0 jusque 3 faire 
    L:=L,octogone(z+(r*2*cos(pi/8)-a)*exp(i*t+i*k*pi/2+i*pi/4),t,r);
    L:=L,octogone(z+2*r*cos(pi/8)*exp(i*t+i*k*pi/2),t,r);
  fpour;
  return L;
}:;
\end{giaconload}
En syntaxe Python~:\\
\begin{giacprog}
def octogone9(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(octogone(z,t,r))
    for k in range(4):
        L.append(octogone(z+(r*2*cos(pi/8)-a)*exp(i*t+i*k*pi/2+i*pi/4),t,r))
        L.append(octogone(z+2*r*cos(pi/8)*exp(i*t+i*k*pi/2),t,r))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogone9(-21,0,4);octogone9(0,pi/4,4);octogone9(20,pi/8,4);}
On peut continuer le pavage, mais il y beaucoup de recouvrements et on dessine 
plusieurs fois la m\^eme chose :\\
\giacinputbig{axes=0;affichage(octogone9(28+(12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone9(-23,0,3),1);affichage(octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3),3+k)$(k=0..3);}\\
\giacinputbig{axes=0;affichage(octogone9(0+(12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone(0,0,3),1)}\\
\giacinputbig{axes=0;octogone9(0,0,3),octogone9((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3)$(k=0..3),octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3)$(k=0..3)}

\section{Le pavage avec un octogone r\'egulier et un carr\'e}
Pour \'eviter des recouvrements on va \'ecrire une proc\'edure qui recouvre un 
rectangle ayant $q$ lignes contenant chacune $p$ octogones faisant un angle 
nul avec l'axe des $x$ et qui juxtapose les octogones pr\'ec\'edents, 
puis on comblera les vides avec une autre proc\'edure qui dessinera les 
m\'edianes des carr\'es manquants.\\
Ces proc\'edures auront les m\^emes param\`etres qui sont :
\begin{itemize}
\item $z$ l'affixe du centre de l'octogne situ\'e en $p=0$ et $q=0$,
\item $t$ la mesure de l'angle que font la ligne des centres avec l'axe des $x$
\item $r$ la longueur d'un c\^ot\'e de l'octogone qui es aussi la longueur d'un 
c\^ot\'e du carr\'e,
\item $p$ le nombre d'octognes sur une ligne et $q$ le nombre d'octognes sur une 
colonne.
\end{itemize}

\subsection{Juxtaposition des octogones}
La fonction {\tt octogonejux} dessine les octogones juxtapos\'es.
En syntaxe Xcas\\
\begin{giaconload}
octogonejux(z,t,r,p,q):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,octogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r);
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def octogonejux(z,t,r,p,q):
    # local L,j,k
    r=float(r)
    L=seq[]
    for j in range(q):
        for k in range(p):
            L=L,octogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r)
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogonejux(0,0,3,7,4)}\\
\giacinputbig{axes=0;octogonejux(-17,pi/6,3,3,3),octogonejux(0,0,3,3,3),octogonejux(27,pi/3,3,3,3)}\\
\subsection{Les m\'edianes des carr\'es manquants}
La fonction {\tt medianes} dessine les m\'edianes des carr\'es manquants.
On utilise comme variables locales :
\begin{itemize}
\item {\tt b} la moiti\'e de la longueur d'un c\^ot\'e du carr\'e,
\item {\tt A} le centre du carr\'e,
\item {\tt k} l'indice de la ligne,
\item {\tt j} l'indice de la colonne.
\end{itemize}
\begin{giaconload}
medianes(z,t,r,p,q):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t));
      L:=L,segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t));
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def medianes(z,t,r,p,q):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-1):
        for k in range(p-1):
            A=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)))
            L.append(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)))
    return(L)
\end{giacprog}
\giacinputbig{octogonejux(-17,pi/6,3,3,3),medianes(-17,pi/6,3,3,3),octogonejux(0,0,3,3,3),medianes(0,0,3,3,3),octogonejux(27,pi/3,3,3,3),medianes(27,pi/3,3,3,3)}
\subsection{Le pavage}
La fonction {\tt octogonepave} r\'eunit les 2 proc\'edures pr\'ec\'edentes et 
dessine le pavage du rectangle ayant $q$ lignes contenant chacune 
$p$ octogones.
En syntaxe Xcas~:\\
\begin{giaconload}
octogonepave(z,t,r,p,q):={
  local L;
  L:=NULL;
  L:=L,octogonejux(z,t,r,p,q);
  L:=L,medianes(z,t,r,p,q);
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def octogonepave(z,t,r,p,q):
    return octogonejux(z,t,r,p,q),medianes(z,t,r,p,q)
\end{giacprog}
\giacinputbig{octogonepave(-17,pi/6,3,3,3),octogonepave(0,0,3,3,3),
octogonepave(27,pi/3,3,3,3)}\\


\section{Les octogones en couleur}
\subsection{Les octogones avec 2 couleurs}
Dans un premier temps, on remplit l'octogne d'une couleur, puis on remplit le 
carr\'e d'une autre couleur, enfin on trace les segments et les contours en noir
et en \'epaisseur 3.

En syntaxe Xcas~:
\begin{giaconload}
octogonep(z,t,r,c1,c2):={
  local L,a;
  L:=[];
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),c1+rempli);
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c2+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),0+epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;
\end{giaconload}
La traduction en syntaxe Python~:
\begin{giacprog}
def octogonep(z,t,r,c1,c2):
    # local L,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),c1+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c2+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),0+epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogonep(-10,0,5,1,3);octogonep(0,pi/8,5,4,2);octogonep(10,pi/3,5,6,5);}
\giacinputbig{axes=0;octogonep(0,0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(3*i*pi/4),0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(i*pi/4),0,4,4,6)}\\
\giacinputbig{axes=0;octogonep(0,0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(k*i*pi/2+i*pi/4),0,4,4,3)$(k=0..3),octogonep(2*4*cos(pi/8)*exp(i*k*pi/2),0,4,4,6)$(k=0..3)}

\subsection{Les octogones avec plusieurs couleurs}
On d\'ecide d'utiliser 3 couleurs.
\begin{giaconload}
octogonep3c(z,t,r,c1,c2,c3):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  pour k de 0 jusque 3 faire 
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*exp(3*i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi/2),z+a*exp(i*t+i*pi/2+i*k*pi/2)),c2+irem(k,2)+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*t+i*k*pi/2),z+r*exp(i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2)),c1+irem(k,2)+rempli);
  fpour;
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c3+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def octogonep3c(z,t,r,c1,c2,c3):
    # local L,k,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    for k in range(4):
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*exp(3*i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi/2),z+a*exp(i*t+i*pi/2+i*k*pi/2)),c2+k % 2+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*t+i*k*pi/2),z+r*exp(i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2)),c1+k % 2+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c3+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogonep3c(0,0,3,1,4,3)}\\
\giacinputbig{axes=0;octogonep3c(20,0,3,120,125,115)}

On d\'ecide d'utiliser 5 couleurs. En syntaxe Xcas~:
\begin{giaconload}
octogonep5c(z,t,r,c1,c2,c3,c4,c5):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  pour k de 0 jusque 1 faire 
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi),z+a*exp(i*t+i*pi/2+i*k*pi)),c2+rempli);
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*pi/2+i*k*pi),z+a*exp(i*t+i*pi/2+i*pi/2+i*k*pi)),c4+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*k*pi),z+r*exp(i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi)),c1+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*pi/2+i*k*pi),z+r*exp(i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi)),c3+rempli);
  fpour;
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),c5+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;
\end{giaconload}
En syntaxe Python~:
\begin{giacprog}
def octogonep5c(z,t,r,c1,c2,c3,c4,c5):
    # local L,k,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    for k in range(2):
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi),z+a*exp(i*t+i*pi/2+i*k*pi)),c2+rempli))
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*pi/2+i*k*pi),z+a*exp(i*t+i*pi/2+i*pi/2+i*k*pi)),c4+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*k*pi),z+r*exp(i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi)),c1+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*pi/2+i*k*pi),z+r*exp(i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi)),c3+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),c5+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogonep5c(0,0,1,4,2,5,3,6)}\\
\giacinputbig{axes=0;octogonep5c(20,0,3,114,122,118,126,110)}


\subsection{Les 9 octogone color\'es}
On tape:
\begin{giaconload}
octogone9p3c(z,t,r,c1,c2,c3):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogonep3c(z,t,r,c1,c2,c3);
  pour k de 0 jusque 3 faire 
    L:=L,octogonep3c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3);
    L:=L,octogonep3c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3);;
  fpour;
  return L;
}:;
octogone9p5c(z,t,r,c1,c2,c3,c4,c5):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogonep5c(z,t,r,c1,c2,c3,c4,c5);
  pour k de 0 jusque 3 faire 
    L:=L,octogonep5c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3,c4,c5);
    L:=L,octogonep5c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3,c4,c5);;
  fpour;
  return L;
}:;
\end{giaconload}
\begin{giacprog}
def octogone9p3c(z,t,r,c1,c2,c3):
    # local L,k,a
    L=seq[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L=L,octogonep3c(z,t,r,c1,c2,c3)
    for k in range(4):
        L=L,octogonep3c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3)
        L=L,octogonep3c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3)
    return(L)

def octogone9p5c(z,t,r,c1,c2,c3,c4,c5):
    # local L,k,a
    r=float(r)
    L=seq[]
    a=r*sqrt(2)*sin(pi/8)
    L=L,octogonep5c(z,t,r,c1,c2,c3,c4,c5)
    for k in range(4):
        L=L,octogonep5c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3,c4,c5)
        L=L,octogonep5c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3,c4,c5)
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogone9p3c(0,0,3,1,4,3)}\\
\giacinputbig{axes=0;octogone9p3c(20,0,3,alea(200)+130,alea(200)+130,alea(200)+130)}
\giacinputbig{axes=0;octogone9p5c(0,0,3,1,4,2,6,3)}\\
\giacinputbig{axes=0;octogone9p5c(20,0,3,alea(10)+50,alea(10)+50,alea(10)+60,alea(10)+60,alea(10)+55)}

\subsection{La ronde des 37=4*9+1 octogones}
\giacinputbig{axes=0;c1,c2,c3,c4,c5:=114,122,118,126,110;
octogone9p5c(0,0,3,c1,c2,c3,c4,c5),octogone9p5c((3*4*cos(pi/8)-3*2*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c1,c2,c3,c4,c5)$(k=0..3),octogone9p5c(3*2*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c2,c3,c4,c5)$(k=0..3)}

\section{Le pavage en couleur}
On modifie la proc\'edure {\tt octogonejux} :\\
\begin{giaconload}
octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,octogonep5c(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,c4,c5);
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
\begin{giacprog}
def octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5):
    # local L,j,k
    L=[]
    r=float(r)
    for j in range(q):
        for k in range(p):
            L.append(octogonep5c(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,c4,c5))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;octogonep5cjux(0,0,3,3,3,1,2,3,4,6)}
On modifie la proc\'edure {\tt medianes} pour remplir le
carr\'e de la couleur {\tt c3} et pour tracer les m\'edianes du carr\'e en 
\'epaisseur 3 :\\
\begin{giaconload}
medianespc(z,t,r,p,q,c5):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,affichage(carre(A+b*sqrt(2)*exp(i*t),A+i*b*sqrt(2)*exp(i*t)),c5+rempli);
      L:=L,affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3);
      L:=L,affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3);
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
\begin{giacprog}
def medianespc(z,t,r,p,q,c5):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-1):
        for k in range(p-1):
            A=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(affichage(carre(A+b*sqrt(2)*exp(i*t),A+i*b*sqrt(2)*exp(i*t)),c5+rempli))
            L.append(affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3))
            L.append(affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3))
    return(L)
\end{giacprog}
On modifie la proc\'edure {\tt octogonepave} :\\
\begin{giaconload}
octogonepave5c(z,t,r,p,q,c1,c2,c3,c4,c5):={
  local L;
  L:=NULL;
  L:=L,octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5);
  L:=L,medianespc(z,t,r,p,q,c5);
  return L;
}:;
\end{giaconload}
\begin{giacprog}
def octogonepave5c(z,t,r,p,q,c1,c2,c3,c4,c5):
    return octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5),medianespc(z,t,r,p,q,c5)
\end{giacprog}
\giacinputbig{axes=0;c1,c2,c3,c4,c5:=114,122,118,126,110;octogonepave5c(-17,pi/6,3,3,3,c1,c2,c3,c4,c5),octogonepave5c(0,0,3,3,3,c1,c2,c3,c4,c5),octogonepave5c(27,pi/3,3,3,3,c1,c2,c3,c4,c5);//c1,c2,c3,c4,c5:=alea(10)+130,alea(10)+150,alea(10)+130,alea(10)+50,alea(10)+210;}\\

\section{Les rosaces en couleur}
\subsection{la proc\'edure {\tt rosaceocto}}
On modifie la proc\'edure {\tt octogone} :\\
Dans {\tt rosaceocto}, on transforme les c\^ot\'es du carr\'e et de l'octogone 
en  arcs de cercle.\\
Les param\`etres sont {\tt z} affixe du centre de l'octogone, {\tt t} angle que
fait une diagonale du car\'e avec l'axe des $x$, {\tt r} le rayon du cercle 
circonscrit \`a l'octogone, 3 couleurs {\tt c1} pour les arcs de l'octogone et {\tt c2} pour les arcs du carr\'e, {\tt c3} pour la couleur du fond (qui vaut par d\'efaut 7) et {\tt u} est l'angle
au centre des arcs qui seront dessin\'es (qui vaut par d\'efaut $3\frac{\pi}{8}$ (on peut choisir d'autres valeurs $\pi/2, \pi/3, \pi/4$)
On utilise {\tt a} comme variable locale pour d\'esigner la moiti\'e de la 
longueur de la diagonale du carr\'e.\\
On tape :
\begin{giaconload}
rosaceocto(z,t,r,c1,c2,c3=7,u=3*pi/8):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,affichage(cercle(z,r),c3+rempli);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  pour k de 0 jusque 3 faire
    L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)),epaisseur_ligne_3);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli);
  fpour;
  pour k de 0 jusque 7 faire 
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli);
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli);
  fpour;
  return L;
}:;
\end{giaconload}
Syntaxe Python~:
\begin{giacprog}
def rosaceocto(z,t,r,c1,c2,equal(c3,7),equal(u,3*pi/8)):
    # local L,k,a
    L=seq[]
    r=evalf(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(affichage(cercle(z,r),c3+rempli))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    for k in range(4):
        L.append(affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)),epaisseur_ligne_3))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli))
    for k in range(8):
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli))
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;rosaceocto(0,0,5,126,118,6)}\\
\giacinputbig{axes=0;c1,c2,c3:=120,125,7;rosaceocto(0,0,3,c1,c2,c3),
rosaceocto((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c1,c2,c3)$(k=0..3),rosaceocto(6*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c2,c3)$(k=0..3)}\\

\subsection{la proc\'edure {\tt rosaceoctogone}}
Dans {\tt rosaceoctogone}, on transforme aussi les segments $PA$,$QC$,$RE$ et $SG$ en arcs de cercle.\\
On utilise comme variables locales {\tt a} pour d\'esigner la moiti\'e de la 
longueur de la diagonale du carr\'e et {\tt b} pour d\'esigner la 
moiti\'e de la longueur du c\^ot\'e du carr\'e\\ 

\begin{giaconload}
rosaceoctogone(z,t,r,c1,c2,c3=7,u=3*pi/8):={
  local L,k,a,b;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  b:=r*sin(pi/8);
  L:=L,affichage(cercle(z,r),c3+rempli);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  pour k de 0 jusque 3 faire
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),-u/2,segment),c1+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),+u/2,segment),c1+rempli);
    L:=L,affichage(triangle(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t)),c1+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli);
  fpour;
  pour k de 0 jusque 7 faire 
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli);
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli);
  fpour;
  return L;
}:;
\end{giaconload}
Syntaxe Python~:
\begin{giacprog}
def rosaceoctogone(z,t,r,c1,c2,equal(c3,7),equal(u,3*pi/8)):
    # local L,k,a,b
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    b=r*sin(pi/8)
    L.append(affichage(cercle(z,r),c3+rempli))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    for k in range(4):
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),(-u)/2,segment),c1+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),u/2,segment),c1+rempli))
        L.append(affichage(triangle(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t)),c1+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli))
    for k in range(8):
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli))
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli))
    return(L)
\end{giacprog}
\giacinputbig{axes=0;rosaceoctogone(0,0,5,126,118,6)}\\
\giacinputbig{axes=0;c1,c2,c3,c4,c5:=alea(20)+130,alea(20)+150,alea(20)+130,alea(20)+50,alea(20)+210;rosaceoctogone(0,0,3,c1,c2),
rosaceoctogone((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c3,c4)$(k=0..3),rosaceoctogone(6*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c5)$(k=0..3)}\\
\subsection{Le pavage avec les rosaces octogonales}
On modifie la proc\'edure {\tt octogonejux} :\\
\begin{giaconload}
rosaceoctogonejux(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,rosaceoctogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,u);
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
\begin{giacprog}
def rosaceoctogonejux(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):
    # local L,j,k;
    L=[]
    r=float(r)
    for j in range(q):
        for k in range(p):
             L.append(rosaceoctogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,u))
    return L
\end{giacprog}
On utilise la proc\'edure {\tt medianespc} qui remplir le cercle circonscrit au
carr\'e de la couleur {\tt c3} et qui trace les m\'edianes du carr\'e en 
\'epaisseur 3 :\\
\begin{giaconload}
rosacemedianes(z,t,r,p,q,c3):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+r*sin(pi/8))*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,affichage(cercle(A,b*sqrt(2)),c3+rempli);
      L:=L,affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3);
      L:=L,affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3);
    fpour;
  fpour;
  return L;
}:;
\end{giaconload}
Syntaxe Python~:
\begin{giacprog}
def rosacemedianes(z,t,r,p,q,c3):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-2+1):
        for k in range(p-2+1):
            A=point(z+(r*cos(pi/8)+r*sin(pi/8))*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(affichage(cercle(A,b*sqrt(2)),c3+rempli))
            L.append(affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3))
            L.append(affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3))
    return(L)
\end{giacprog}
On modifie la proc\'edure {\tt octogonepave} :\\
\begin{giaconload}
rosaceoctogonepave(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):={
  local L;
  L:=NULL;
  L:=L,medianespc(z,t,r,p,q,c3);
  L:=L,rosaceoctogonejux(z,t,r,p,q,c1,c2,c3,u);
  return L;
}:;
\end{giaconload}
Syntaxe Python~:
\begin{giacprog}
def rosaceoctogonepave(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):
    return medianespc(z,t,r,p,q,c3),rosaceoctogonejux(z,t,r,p,q,c1,c2,c3,u)
\end{giacprog}
\giacinputbig{axes=0;rosaceoctogonepave(0,0,3,3,3,4,4)}
\giacinputbig{axes=0;rosaceoctogonepave(0,0,3,3,3,4,4,6)}
\end{giacjshere}
\end{document}
