Triangle de Sierpiński (programme informatique)

Ces programmes récursifs écrits en C soit Java, permettent de générer des triangles de Sierpiński.

En C

Ce programme utilise la bibliothèque graphique Allegro.

<source lang="c">

/* pour compiler taper en ligne de commande :

  gcc triangle.c -o triangle `allegro-config --libs`
  pour exécuter taper triangle suivi du nombre d'itérations :
  triangle 7
  */

1. include <stdlib.h>
2. include <math.h>
3. include "allegro.h"

1. define MAXX 768
2. define MAXY 665
3. define OX 5
4. define OY 5
5. define TX 758
6. define TY 655

BITMAP *bmp;

/* fonction récursive, qui a pour paramètres :

  les coordonnées (x, y) de l'extrémité gauche de la base d'un triangle équilatéral, 
  a la longueur d'un de ses cotés et 
  n le nombre d'itérations */

void triangle_Sierpinski(double x, double y, double a, int n) {

 double b=-a*sqrt(3.0)/2;
 /* négatif à cause de l'orientation 
    de l'axe des ordonnées vers le bas */
 if (n>0)
   {
     /* on dessine un triangle plein */
     triangle(bmp, (int) x, (int) y, (int) (x+a), (int)y, (int)(x+a/2),(int)(y+b), 4);
     /* et on supprime le petit triangle central */
     triangle(bmp, (int) (x+a/2), (int) y, (int) (x+3*a/4), (int)(y+b/2), (int)(x+a/4),(int)(y+b/2), 0);
     /* appels récursifs */
     triangle_Sierpinski(x, y, a/2, n-1);
     triangle_Sierpinski(x+a/2, y, a/2, n-1);
     triangle_Sierpinski(x+a/4, y+b/2, a/2, n-1);
   }  

}

int main(int argc, char *argv[]) {

 unsigned long n=1;
 if (argc>1) n=strtoul(argv[1], NULL, 10);
 
 /* initialisation de allegro */
 allegro_init();
 
 set_color_depth(8);
 
 /* fixe la palette */
 set_palette(desktop_palette);
 
 bmp = create_bitmap(MAXX, MAXY);
 if(!bmp)
   {
     allegro_message("Ne peut pas créer l'image\n");
     return 1;
   }
 
 triangle_Sierpinski(OX, OY+TY, TX, (int)n);
 
 save_bitmap("Triangle_de_Sierpinski.pcx", bmp, desktop_palette);
 destroy_bitmap(bmp);
 
 return 0;

}

END_OF_MAIN(); /* note finale des programmes allegro */ </source>

En Java

La méthode récursive private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) accepte des coordonnées de trois points (coins du triangle principal) plus ou moins arbitraires.

• Pour Compiler (vous devez disposez du JDK Java) : javac SierpinskiTriangle.java
• Pour exécuter :
  • Avec un éditeur de texte, créez le fichier SierpinskiTriangle.html dans le même répertoire que SierpinskiTriangle.class créé lors de la compilation. Copiez-y le code html ci-dessous.
  • Ouvrez le fichier SierpinskiTriangle.html avec un navigateur comme Firefox.

Source de SierpinskiTriangle.html : Java n'est pas installé !

Source de SierpinskiTriangle.java : /* Nom du fichier : SierpinskiTriangle.java */ import java.awt.*; import java.applet.*;

public class SierpinskiTriangle extends Applet {

   private Graphics g;
   private int dMin=8;    // limite à la récursion en pixels

   public void paint(Graphics g) {
       this.g = g;
       int d  = 1024;    // base (largeur du triangle)
       int x0 =   50;    // distance de gauche
       int y0 =   50;    // distance du haut
       int h  = (int)(d*Math.sqrt(3)/2);    // hauteur
           // adapté à un triangle équilatéral

   //  spécification du triangle principal: points A, B, C
       int xA=x0,      yA=y0+h;    // (bas-gauche)
       int xB=x0+d,    yB=y0+h;    // (bas-droite)
   //  int xB=x0,      yB=y0;      // (haut-gauche)
   //  int xB=x0+d,    yB=y0;      // (haut-droite)
       int xC=x0+d/2,  yC=y0;    // triangle équilatéral (haut-milieu)
   //  int xC=x0,      yC=y0;    // (haut-gauche)
           // triangle perpendiculaire, angle droit près A
   //  int xC=x0+d,    yC=y0;    // (haut-droite)
           // triangle perpendiculaire, angle droit près B
       int[] x = { xA, xB, xC };
       int[] y = { yA, yB, yC };

       drawSierpinskiTriangle( x, y, d/2 );     // démarrer la récursion
   }

   private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) {
       if (d<dMin) g.fillPolygon ( x, y, 3 );   // fond de la récursion
       else {
           // milieus des cotés du triangle:
           int xMc = (x[0]+x[1])/2,    yMc = (y[0]+y[1])/2;
           int xMb = (x[0]+x[2])/2,    yMb = (y[0]+y[2])/2;
           int xMa = (x[1]+x[2])/2,    yMa = (y[1]+y[2])/2;

           int[] xNouveau1 = { x[0], xMc, xMb };
           int[] yNouveau1 = { y[0], yMc, yMb };
           drawSierpinskiTriangle ( xNouveau1, yNouveau1, d/2 );    // récursion

           int[] xNouveau2 = { x[1], xMc, xMa };
           int[] yNouveau2 = { y[1], yMc, yMa };
           drawSierpinskiTriangle ( xNouveau2, yNouveau2, d/2 );    // récursion

           int[] xNouveau3 = { x[2], xMb, xMa };
           int[] yNouveau3 = { y[2], yMb, yMa };
           drawSierpinskiTriangle ( xNouveau3, yNouveau3, d/2 );    // récursion
       }
   }

} </source>

Article publié sur Wikimonde Plus