La roue hexagonale ou isopolygonale

Retour à la page personnelle de Bernard Parisse.

# Chapitre 19 La roue hexagonale ou isopolygonale

Un polygone régulier roule sur l’axe des x. Tracer la trajectoire d’un sommet A.
Exprimer la distance parcourue par le point A quand la "roue" a fait un tour complet.

## 19.1 La roue hexagonale

Avec `Xcas` on pourra exécuter `hexagone.xws` pour avoir la correction.

On peut chercher la liste `S` des affixes des sommets de l”hexagone lorsque `A` est en `0` et `B` est en `1`, puis utiliser `polygone(S)` ou utiliser directement `hexagone(0,1)` ou `isopolygone(0,1,6)`.
Lorsque la "roue" a fait un tour complet, le point `A` décrit 6 arcs de cercle et on met dans `L` les extrémités de ces arcs (le dernier arc est de rayon nul donc on peut dire que la trajectoire est formée de 5 arcs). Pour calculer ces extrémités on tape :
`a:=normal(affixe(rotation(1,-pi/3,0)));`
`b:=normal(affixe(rotation(2,-pi/3,a)))`,
puis on complète par symétrie par rapport à x=3
`AL` est la liste de ces 5 arcs lorsque la "roue" a fait un tour complet.
`BL` est la liste `AL` translatée : on a ainsi la trajectoire du point `A` lorsque la "roue" a fait 2 tours complets.
On définit `Hs` la figure formée par l’hexagone de centre `O` et le segment `AO` : on visualise ainsi le point `A`.
Pour faire une animation on va créer la liste `LH` contenant plusieurs positions de `Hs` obtenues par deux rotations de centre 1 d’angle −π/6 et −π/3, deux rotations de centre 2 d’angle −π/6 et −π/3 etc... On obtient ainsi une liste de 12 éléments.
On tape :

    L:=[0,1/2+i*sqrt(3)/2,2+i*sqrt(3),4+i*sqrt(3),11/2+i*sqrt(3)/2,6];
    affichage((AL:=seq(arc(L[k],L[k+1],-pi/3),k,0,4)),hidden_name);
    affichage((BL:=translation(6,AL)),hidden_name);
    Hs:=[isopolygone(0,1,6),segment(0,(1+i*sqrt(3))/2)];
    LH:=[Hs];
    for (j:=0;j<12;j++){LH:=concat(LH,[rotation(j+1,-pi/6,LH[2*j]),rotation(j+1,-pi/3,LH[2*j])])}:;
    affichage((A:=seq(arc(L[k],L[k+1],-pi/3),k,0,4)),hidden_name);
    affichage((B:=translation(6,A)),hidden_name);
    animation(LH);

Le point A décrit des 6 arcs de cercles qui sont :

- un arc de rayon 1 et d’angle au centre π/3 donc de longueur π/3,
- un arc de rayon r2=(−2+1/2)2+(√(3)/2)2=3 et d’angle au centre π/3 donc de longueur π√3/3,
- un arc de rayon 2 et d’angle au centre π/3 donc de longueur 2π/3,
- un arc de rayon √3 et d’angle au centre π/3 donc de longueur π√3/3,
- un arc de rayon 1 et d’angle au centre π/3 donc de longueur π/3,
- un arc de rayon 0 et d’angle au centre π/3 donc de longueur 0.

donc la distance parcourue par le point A quand la ‘"roue" a fait un tour complet est π(4+2√3)/3.
On peut aussi calculer cette longueur à l’aide d’une boucle. On tape :
`dist:=0;`
`for (k:=0;k<5;k++){arc(L[k],L[k+1],-pi/3,C,R);
dist:=dist+R*pi/3;};`
`normal(dist)`

## 19.2 La roue isopolygonale

Avec `Xcas` on pourra exécuter `rouepoly.xws` pour avoir la correction.

On va écrire des procédures de param‘etre `n` qui représente le nombre de côtés de l’isopolygône.
`Lsarc(n)` renvoie la liste des sommets des arcs qui forment la trajectoire de `A`.
`Lpoly(n)` renvoie la liste des positions successives de la figure formée par `P` l’isopolgône de centre `O`, et `S` le segment `OA`. On pourra ainsi faire facilement une animation.
`tracerarc(n)` ou `tracer(n)` trace la trajectoire lorsque la "roue" a fait 2 tours complets. `longtrajet(n)` renvoie la longueur d’une arche : le résultat est approché, mais on peut supprimer `evalf` pour avoir un résultat exact lorsque `n=3,4,6`.

On tape :

      Lsarc(n):={
        local L,j;
        L:=[point(0)];
        for (j:=1;j<n;j++){
          L:=concat(L,normal(rotation(j,-2*pi/n,L[j-1])));
        }
        return(L);
      };

    Lpoly(n):={
    local LP,j,P,S;
    P:=normal(isopolygone(0,1,n));
    S:=segment(0,evalf(1/2+i/2/tan(pi/n)));
    LP:=[[P,S]];
    for (j:=0;j<2*n;j++){
    LP:=concat(LP,[rotation(j+1,evalf(-pi/n),LP[2*j]),
               rotation(j+1,evalf(-2*pi/n),LP[2*j])]);
    }
    return LP;
    };

    tracerarc(n):={
      local A,B,Ls;
      Ls:=evalf(Lsarc(n));
      A:=seq(arc(Ls[k],Ls[k+1],evalf(-2*pi/n)),k,0,n-2);
      B:=translation(n,A);
      return concat(A,B);
    };

    //ou encore
    tracer(n):={
      local A,B,j,Ls;
      Ls:=evalf(Lsarc(n));
      A:=[arc(Ls[0],Ls[1],evalf(-2*pi/n))];
      for (j:=1;j<n-1;j++){
        A:=concat(A,arc(Ls[j],Ls[j+1],-2*pi/n));
      }
      B:=translation(n,A);
      return(A,B)
    };

    longtrajet(n):={
    local dist,k,C,R;
    dist:=0
    for (k:=0;k<(n-1);k++){
      arc((Lsarc(n))[k],(Lsarc(n))[k+1],-pi/3,C,R);
      dist:=evalf(dist+R*pi/3);
    };
    return normal(dist);
    }

On tape par exemple, pour avoir une animation :
`tracerarc(5);animation(Lpoly(5))`

Retour à la page personnelle de Bernard Parisse.