Arbre de Pythagore

Réalisé par Guillaume PAYET

Cette année de formation, nous avons découvert CaRMetal et la partie programmation de ce logiciel le « CaRScript ». Lors de cette formation organisée par Mr Martin, nous avons pu voir divers aspects de ces scripts, notamment les fonctions. Voici un petit programme assez simple nous permettant de réaliser une « figure récursive » que j’ai appelée « arbre de Pythagore sous le vent ».

Le dessin produit, assez joli au final, pourrait être intéressant à réaliser en classe de 6^e afin de manipuler la règle, l’équerre, le rapporteur et le compas par exemple( à condition de ne pas prendre un nombre d’itération trop grand). C’était dans ce sens que j’avais, au départ, réalisé ce programme. J’y ai rajouté un curseur qui peut être manipulé dans l’exécution du script et cela donne à la fin l’impression d’un arbre sous le vent d’où le nom : « arbre de Pythagore sous le vent ». A chaque itération, à partir de deux points , on construit un carré (le « premier » coté étant construit à partir des deux points) ; sur le coté opposé au premier coté on construit un triangle rectangle , et puis deux autres carrés qui reposent eux sur les autres cotés du triangle.

On construit ainsi à chaque itération la figure iteration1.

Cependant, on pourrait aussi l’utiliser afin d’illustrer la récursivité dans la programmation. En effet, le caractère visuel de la figure peut être exploité pour parcourir l’arbre,ainsi l’aspect récursif se voit assez facilement en regardant la construction de la figure au fur et à mesure. On peut aussi exploiter la figure pour chercher combien de fois on a fait « tourner » la machine.

Cela pourrai être une piste pour envisager la récursivité de façon très imagé.

Le programme

Pour l’exécution du « CarScript » on a besoin d’une figure « CaRMetal » avec deux points A et B ainsi que d’un curseur nommé angle qui varie entre 0 et 90.
( cet angle entre en jeu dans la construction du triangle).

Après une exécution avec 6 itérations on obtient la figure suivante :

Le script en copie d’écran dans l’éditeur :

//il faut créer deux points A et B et uncruseur nommé angle qui varie entre 0 et 90
function pyth(z,t,k){
	d=z;c=t;
	k--;
	if (k>=0){
		pi=Point("x_c+sin(angle)*(y_d-y_c)+cos(angle)*(x_d-x_c)","y_c-sin(angle)*(x_d-x_c)+cos(angle)*(y_d-y_c)");
		SetHide(pi,true);
		ti=Line(pi,c);SetHide(ti,true);
		oi=Perpendicular(ti,d);	SetHide(oi,true);
		e=Intersection(ti,oi);	SetColor(e,"red");
		var f=Point("x_c-y_c+y_e","y_c+x_c-x_e");
		var g=Point("x_e-y_c+y_e","y_e+x_c-x_e");
		var h=Point("x_e-y_e+y_d","y_e+x_e-x_d");
		var i=Point("x_d-y_e+y_d","y_d+x_e-x_d");
		SetColor(f,"red");SetColor(g,"red");SetColor(h,"red");SetColor(i,"red")
		s5=Segment(e,d);
		s6=Segment(e,c);
		s7=Segment(c,f);
		s8=Segment(f,g);
		s9=Segment(g,e);s10=Segment(e,h);s11=Segment(h,i);s12=Segment(i,d);
		SetColor(s5,"green");SetColor(s6,"green");SetColor(s7,"green");SetColor(s8,"green");
		SetColor(s9,"green");SetColor(s10,"green");SetColor(s11,"green");SetColor(s12,"green")
		pyth(g,f,k);
		pyth(i,h,k);
	}
}

k=Input("nombre d'itération");
//on définie le nombre de branche de l'arbre( attention à ne pas prendre k trop grand (k<10), 
// sinon cela prend du temps)
//placer deux points A et B et un curseur nommé angle vaiant de 0 à 90
a="A";b="B";
c=Point("x_b-y_b+y_a","y_b+x_b-x_a");
d=Point("x_a-y_b+y_a","y_a+x_b-x_a");
//construction du tronc de l'arbre
s1=Segment("s1",a,b);s2=Segment("s2",c,b);
s3=Segment("s3",c,d);s4=Segment("s4",a,d);
SetColor("s1,s2,s3,s4","brown");
pyth(d,c,k);

Copie d’écran (avec les points plus gros pour l’aspect « chou fleur ») en cours de l’exécution de l’itération 8.

Version finale pour l’itération 8, avec des points de taille maximale (la taille est modifiable pendant ou après le script, de même l’angle est modifiable pendant l’exécution du script)

Commentaire du formateur

Ce script est le premier avoir été proposé spontanément, un mois avant la séance de mise en commun. En séance de formation quelques exemples récursifs avaient été montrés mais sans que les détails sur la gestion des fonctions aient été présentés.

Cette production est donc totalement autonome, sur la base de lectures des scripts téléchargeables proposés en formation. Guillaume est, de fait, devenu une personne ressource pour les autres stagiaires.

Je serais moins optimiste sur la réalisation de l’itération par des élèves de 6° ... Pour la manipulation des outils de construction de ces élèves, on peut, de manière plus réaliste, se replier sur des figures proches de celles proposées à cet article (CM2-6°), mais il n’y a pas de rapporteur.

Spirale de Pythagore

Script réalisé par Aurélie BELON, François CADET et Ludovic LEGROS

Les stagiaires étant, pour l’essentiel, en collège, souvent en 4°, les scripts autour de Pythagore ont beaucoup inspiré les thèmes de production.

Ce groupe a travaillé sur la spirale de Pythagore. Ils ont commencé par faire cette première figure :

dont ils étaient très contents. C’est après tout un premier script non élémentaire qui fait bien ce qu’ils avaient prévu. D’un point de vue du formateur, c’était assez peu esthétique, j’ai proposé, à partir du deuxième tour, de ne garder que le segment qui ne recoupe pas ce qui a déjà été construit, pour plus de lisibilité. C’est-à-dire réaliser quelque chose qui ressemble plus à cela :

Les stagiaires sont partis sur l’utilisation d’un item CaRScript « Angle » au comportement pas facile à maitriser, et je leur ai fait perdre du temps en ne les mettant pas tout de suite en garde sur cet item qui ne fonctionne pas toujours comme on l’imagine.

Les stagiaires ont donc fait un script suivant les conseils du formateur : n’utiliser que des intersections de droite. L’aspect un peu ésotérique (un point B qui s’appelle o etc) et non documenté du script rend compte des difficultés à obtenir ce qui été recherché, mais cela a aboutit.

Copie d’écran du script

Et pour 305 points on obtient une belle figure qui fait apparaître la spirale.

s=Point("A",0,0);o=Point("B",-1,0);
p=Point("a0",-1,-1);g=Segment("A","B");
h=Segment("AC","A","a0");u=Segment("v0","a0","B");
jj=0;
for (i=1; i<305; i=i+1){
	n=Perpendicular(h,p);
	j=FixedCircle(p,1);
	l=Intersection("a"+i,j,n);
	SetHide(j,true);
	SetHide(n,true);
	if (i<16){
		h=Segment(s,l);
		v=Segment("v"+i,p,l);
		p=l;
	} else {
		q=Line("A","a"+jj);SetHide(q,"true");
		qq=Line("a"+(i-1),"a"+i);SetHide(qq,"true");
		u=Intersection(qq,q);SetHide(u,"true");
		x1=X("a"+(i-1));y1=Y("a"+(i-1));
		x2=X(u);y2=Y(u);
		lu=Math.sqrt((y2-y1)*(y2-y1)+(x2-x1)*(x2-x1))
		h=Segment(s,l);
		SetHide(h,true);
		v=Segment("v"+i,p,l);
		
		if (lu>=1) {k=Intersection("k"+i,"v"+jj,h);
		} else {jj=jj+1;k=Intersection("k"+i,"v"+jj,h);
		}
		p=l;
		SetHide(k,true);
		z=Segment(l,k);
	}
}

Commentaire du formateur

On notera l’utilisation des fonction X et Y qui donnent les coordonnées d’une variable JavaScript dans la figure. L’utilisation de cette fonction rend (ou n’est utilisable que pour) une figure non dynamique.

Deux prolongements possibles
a) Rendre la figure dynamique (ie pour que le premier point puisse être sur le cercle de centre O de rayon 1.
b) Il avait été proposé aux stagiaires de poursuivre en coloriant de couleurs différentes les polygones obtenus qui peuvent être un triangle, un quadrilatère ou un pentagone. Dans la foulée, ce n’es pas si difficile à faire, mais peut quand même demander un peu de temps.

Spirale d’Or

Réalisé par AUZANNEAU Marie, JORIS Emmanuelle, MOUTOUSSAMY Marius, et PICARD Audrey

Nous sommes quatre étudiants en PLC2 Mathématiques et nous allons vous présenter un sujet concernant la spirale d’Or….

Dans un premier temps, nous allons introduire le nombre d’or accompagné d’un historique, puis nous expliquerons la construction de la spirale d’or à partir du triangle d’or. Enfin nous verrons le programme conçu sur JavaScript permettant cette construction sur CarMetal.

I) Le nombre d’or

Le nombre d’or, désigné par la lettre $\phi$(phi) de l’alphabet grec en l’honneur de Phidias, sculpteur et architecte grec du Parthénon, est le nombre irrationnel

$$\phi = \dfrac{\sqrt{5}+1}{2} \approx 1,6180339887...$$

a) Historique

• Il y a 10 000 ans : Première manifestation humaine de la connaissance du nombre d’or (temple d’Andros découvert sous la mer des Bahamas).

• 2800 av JC : La pyramide de Khéops a des dimensions qui mettent en évidence l’importance que son architecte attachait au nombre d’or.

• V^e siècle avant J-C. (447-432 av. JC) : Le sculpteur grec Phidias utilise le nombre d’or pour décorer le Parthénon à Athènes, en particulier pour sculpter la statue d’Athéna Parthénos.

• III^e siècle avant J-C. : Euclide évoque le partage d’un segment en « extrême et moyenne raison » dans le livre VI des Eléments.

• 1498 : Fra Luca Pacioli, un moine professeur de mathématiques, écrit De divina proportione (« La divine proportion »).

• Au XIX^e siècle : Adolf Zeising (1810-1876), docteur en philosophie et professeur à Leipzig puis Munich, parle de « section d’or » et s’y intéresse non plus à propos de géométrie mais en ce qui concerne l’esthétique et l’architecture. Il cherche ce rapport, et le trouve dans beaucoup de monuments classiques. C’est lui qui introduit le côté mythique et mystique du nombre d’or.

• Au début du XX^e siècle : Matila Ghyka, diplomate roumain, s’appuie sur les travaux du philosophe allemand Zeising et du physicien allemand Gustav Theodor Fechner ; ses ouvrages L’esthétique des proportions dans la nature et dans les arts (1927) et Le Nombre d’or. Rites et rythmes pythagoriciens dans le développement de la civilisation occidentale (1931) insistent sur la prééminence du nombre d’or et établissent définitivement le mythe.

• Au cours du XX^e siècle : des peintres tels Dali et Picasso, ainsi que des architectes comme Le Corbusier, eurent recours au nombre d’or.

• 1945 : Le Corbusier fait breveter son Modulor qui donne un système de proportions entre les différentes parties du corps humain.

b) Caractéristiques mathématiques

$\phi$ possède de nombreuses propriétés mathématiques remarquables. En voici quelques une…

Le nombre d’or est la solution de l’équation $x^2-x-1 = 0$ avec la suite de Fibonnacci.

Pour calculer le carré du nombre d’or, il suffit de lui ajouter 1, en effet : $\phi^2 = \phi +1$

c) Dans la nature

Le nombre d’or est-il vraiment une clé universelle d’harmonie ? Sans aller aussi loin, il est sûr qu’il est présent dans la nature.
Le nautile est un coquillage dont la rareté interdit désormais la vente (souvent proposé comme souvenir de plage). On a pu constater que sa coquille est en forme de spirale, comme tous les coquillages. Mais celle-ci est une spirale d’or ! On observe également ces spirales dans le cœur de tournesol, l’ananas, les feuilles de chêne, les fleurs dont les pétales sont en hélice. Certaines personnes avancent même un argument évolutionniste pour justifier cette omniprésence. La disposition des feuilles selon la spirale d’or permettrait aux plantes de bénéficier de la meilleure exposition possible au soleil, d’où une meilleure croissance.

II) Construction de la spirale d’or

Un rectangle d’or est un rectangle dont le rapport de la longueur sur la largeur est égal au nombre d’or.
Prenez un rectangle d’or ( tel que$\dfrac{Longueur}{largeur} =\phi$). Enlevez-lui un carré formé à partir du plus petit côté. Le rectangle restant est un rectangle d’or ! On peut ainsi continuer l’opération à l’infini.
Dans les carrés, en traçant successivement les quarts de cercle joignant deux sommets on obtient une spirale logarithmique, dite spirale d’or.

A partir d’un rectangle d’or (choisi arbitrairement) notre programme se propose à l’aide de boucles de commencer la spirale, le nombre d’itération est ici de 5, il est possible de le modifier. Ainsi il est possible d’avoir une spirale plus ou moins « longue ».

// Initialisation des variables et creation du premier rectangle d'or

phi=(1+Math.sqrt(5))/2;

Point("A0",0,0);
Point("B0","x(A0)","y(A0)+1");
Point("C0","x(A0)+_phi","y(B0)");
Point("D0","x(C0)","y(A0)");
s1=Segment("A0","B0");
s3=Segment("C0","D0");s4=Segment("D0","A0");
k=0;

// La boucle (le nombre d'itération est modifiable...)
for (i=1; i<6; i=i+1){
 // k est un switch qui vaut 0 ou 1 pour la désigntion du point D.
 k=1-k;
 j=i-1;
 // Construction du nouveau rectangle:
 c1=Circle("B"+j,"A"+j);
 SetHide("_c1",true);
 s2=Segment("B"+j,"C"+j);
 Intersection("A"+i,s2,c1);
 Point("B"+i,"x(C"+j+")","y(C"+j+")");
 Point("C"+i,"x(D"+j+")","y(D"+j+")");
 if (k==1){
  Point("D"+i,"x(A"+i+")","y(C"+i+")");
 } else {
  Point("D"+i,"x(C"+i+")","y(A"+i+")");
 }
 s4=Segment("A"+i,"D"+i);
 //Pour tracer l'arc de cercle il nous faut trois points et donc le rayon

 q=Math.sqrt(Math.pow(X("B"+j)-X("A"+j),2)+Math.pow(Y("B"+j)-Y("A"+j),2))
 //construction du point G le troisieme point

 Point("G"+i,X("D"+i)+Math.pow(-1,Math.floor((i+2)/2))*q*Math.cos(Math.PI/4),Y("D"+i)+Math.pow(-1,Math.floor((i+3)/2))*q*Math.cos(Math.PI/4));
 // Construction de l'arc de cercle:
 // a) on place le troisième point nécessaire à la construction de l'arc
 //Point("G"+i,X("D"+i)-q*Math.cos(Math.PI/4),Y("D"+i)+q*Math.sin(Math.PI/4));
 //  b) on construit la spirale:
 arc=Arc3pts("A"+j,"G"+i,"A"+i);
}

Le code tel qu’il apparaît dans l’éditeur du logiciel

Quelques zooms sur la figure produite avec i<15

Figure initiale

Zoom 1 sur le petit rectangle au centre

Zoom 2 à nouveau sur le rectangle central

Commentaire du formateur

Contrairement à ce que pourrait suggérer une lecture un peu rapide du code, ce script est particulièrement technique, et difficile. Il suffit de lire la dernière ligne du code pour voir que les points sont indicés par deux indices. Contrairement aux autres spirales usuelles, celle-ci est bien plus complexe à réaliser. Je ne suis pas convaincu que la ligne 34 soit la façon la plus simple de résoudre le problème rencontré. Manifestement cette ligne de code a son histoire ...

Amélioration possible :
a) cosmétique : le script correct ayant été difficile à obtenir, les stagiaires ont laissé trace de tous les points, pour vérifier les étapes. Pour les cacher, il suffit de nommer les points utilisés avec des noms de variables JS et d’utiliser un SetHide.
b) dynamique : quand Marius écrit « À partir d’un rectangle d’or choisi arbitrairement, notre programme ... », il veut dire « de taille quelconque » car, dans le code, les rectangles d’or ont nécessairement leurs côtés parallèles aux axes de coordonnées. Ce serait un autre travail que de rendre cette production réellement dynamique, correcte en déplaçant une base du rectangle d’or initial.
c) Une réécriture dynamique gagnerait probablement en simplicité et en lisibilité si elle était récursive.

Les spirales ordinaire (Archimède et autres) ont déjà été proposées à cette page (avec animation en ligne).

Sierpinski Récursif

Réalisé par Jérôme INSULAIRE et Nicolas LEVESCOT

Travaillant en lycée sur les suites géométriques, les stagiaires de ce groupe proposent le thème du triangle de Sierpinski. Vu de manière statique en formation, la demande est donc de faire autre chose, autrement. D’où la proposition récursive :

p=Point(-5,5);q=Point(-2,-4);r=Point(5,1);

function Sierp(a,b,c,n){
	n--;
	if (n==0){return

	} else {
		var i=MidPoint(a,b);var j=MidPoint(b,c);var k=MidPoint(c,a);
		SetHide(i,true);SetHide(j,true);SetHide(k,true);
		var s=i+","+j+","+k;
		Polygon(s);
		Sierp(a,i,k,n);Sierp(b,j,i,n);Sierp(c,k,j,n);

	}	
}
Segment(p,q);Segment(q,r);Segment(r,p);
Sierp(p,q,r,4);

L’étape 4 donne la figure dynamique suivante :

Divertissement sur le script

Étape 6 :

Zoom sur cette figure :

Le script a été réalisé aussi en accompagnement d’un diaporama powerpoint bien détaillé sur le thème de l’aire et du périmètre de figures ainsi itérées (flocon de Koch, triangle de Sierpinski) , qu’il convient bien entendu d’utiliser avec prudence en classe ...

Étude d’une série statistique en collège

Réalisé par Mélissa TSANG-CHIN-SANG

On veut étudier une série statistique au collège. Les valeurs de la série sont les nombres d’enfants (0,1, 2, 3, 4), les effectifs sont les nombres d’employés qui ont respectivement 0,1, 2, 3, 4 enfants. On crée aléatoirement une série d’effectifs allant de 0 à 10.

I. Positions relatives de la moyenne et de la médiane

On s’intéresse aux caractéristiques de position comme la moyenne et la médiane. Pour cela, on crée des points dans CaRMetal que l’on va déplacer grâce au script.
On commence donc par créer une figure initiale : on trace un axe d’origine « orig ». On y place un point « Moy » et un point « Med ».

I.a. Médiane

La médiane est une notion vue en 3ème.

On entre une série statistique ordonnée. La médiane est alors une valeur qui partage la série en deux parties de même effectif.
On calcule l’effectif total c[t]. La médiane est alors la $\frac{c[t]+1}{2}$ ième des valeurs.

I.b. Moyenne pondérée

La moyenne pondérée est abordée en 4ème .

Dans un premier temps, on calcule le produit des valeurs par leurs effectifs. Puis on fait la somme q[t] de ces produits. Enfin on la divise par la somme c[t] des effectifs.

Les élèves peuvent voir que, suivant les effectifs, on peut avoir Moy < Med ou Moy > Med et qu’en règle générale, la moyenne est différente de la médiane.

II. Représentations graphiques

Si les élèves apprennent à lire des informations à partir d’un diagramme dès la 6ème , c’est en 5ème qu’ils apprennent à représenter des données sous la forme d’un diagramme.

II.a. Diagramme en bâtons

On commence par créer un diagramme en bâtons sur la figure initiale. Pour cela, on trace des segments $M_iN_i$, $0\leq i \leq 4$.
Les abscisses des points $M_i$ et $N_i$ correspondent à la valeur i.
Tous les points $M_i$ ont pour ordonnée 0.
Dans un premier temps, tous les points $N_i$ ont pour ordonnée 1.
On utilise la fonction « Move » pour déplacer le point à chaque nouveau tableau d’effectifs de sorte qu’il garde son abscisse et que son ordonnée correspondant à l’effectif de la valeur i.

II.b. Diagramme circulaire

On trace sur la figure initiale un cercle de centre O, des segments [O$B_i$] pour $0\leq i \leq 4$.
On fait attention à ce que les points $B_i$ ne se trouvent pas sur le cercle, sinon la fonction « Move » ne fonctionnera pas avec ces points.

L’angle $\widehat{B_{i-1}OB_i}}$ est proportionnel à l’effectif e[i] de la valeur i.
On va déplacer $B_i$ de sorte que l’angle $\widehat{B_0OB_i}}$ soit proportionnel à $e_i$ = e[0]+…+e[i].
Cet angle sera donc égal à $\frac{360e_i}{ct}$ où ct est l’effectif total.

Pour utiliser la fonction « Move », on calcule alors l’abscisse de $B_i$ en fonction de l’abscisse du centre O et du rayon du cercle. On fait de même pour l’ordonnée de $B_i$ en fonction cette fois de l’ordonnée de O.

Les élèves peuvent constater que pour une valeur donnée, plus un bâton du diagramme en bâtons est grand, plus l’angle du diagramme circulaire correspondant est grand.

On réitère le script 5 fois, c’est-à-dire qu’on étudie la série pour 5 tableaux d’effectifs différents. Pour obtenir la deuxième série d’effectifs aléatoires, on appuie sur le bouton « suivant ».

Cette activité est un bon rappel des notions abordées tout au long des années du collège en statistique.

//Répartition des employés d'une entreprise en fonction du nombre d'enfants

//nombre d'enfants: série statistique ordonnée
n=Array(0,1,2,3,4);

//(taille de n)-1
t=4;

e=new Array;
p=new Array;
q=new Array;
c=new Array;
a="A";

for (jj=0; jj<5; jj=jj+1){

	//tableau d'effectifs (nombre d'employés)
	for (i=0; i<t+1; i++){e[i]=Math.ceil(10*Math.random());
	}

	//tableau d'effectifs cumulés
	c[0]=e[0];
	for (i=0; i<t; i++){c[i+1]=c[i]+e[i+1];
	}

	//	tableau de fréquences
	//	Println("effectif"+"|"+"fréquence");
	//	for (i in n){Println(e[i]+"|"+e[i]/c[t]);
	}
	//
	//	médiane
	i=0;
	while (c[i]<(c[t]+1)/2){i=i+1;
	}
	mediane=n[i];
	Move("Med","x(orig)+_mediane",9);

	//moyenne:taleau des produits nbre d'enfants x effectif
	for (i in n){p[i]=n[i]*e[i];
	}

	q[0]=p[0];
	for (i=0; i<t; i=i+1){q[i+1]=q[i]+p[i+1];
	}
	moyenne=q[t]/c[t];
	Move("Moy","x(orig)+_moyenne",9);

	//diagramme en bâtons
	for (i in n){
		Move("N"+i,i,e[i]);
	}

	//diagramme circulaire
	ct=c[t];ei=0
	for (i in n){
		ei=ei+e[i];
		Move("B"+i,"x(O)+2*cos(_ei*360/_ct)","y(O)+2*sin(_ei*360/_ct)");
		
	}
	Stop=true;
	while (Stop){
		suivant=GetExpressionValue("suiv");
		Stop=!suivant;
	}

	Pause(500);
}

Sorties Écran de la figure

On remarque que l’indice des points sur le cercle indique l’extrémité du secteur traité : $B_0$ est l’extrémité du secteur, d’origine $B_4$ : ce secteur correspond à l’effectif décrit par le premier bâton d’origine $M_0$. Dans cette première illustration, la moyenne est inférieure à la médiane.

Ci dessus la médiane est supérieure à la moyenne.
Et dans l’illustration suivante les deux sont très proches.

Commentaire du formateur

Le texte proposé es le seul qui détaille le script mis en place, les autres ne parlent jamais ni de leur programmation, ni des difficultés algorithmiques rencontrées.

Comme les autres ce script a une histoire : la stagiaire a proposé cette figure avec une seule utilisation possible. Ce qui fut une surprise de talle pour le formateur, est l’usage spontané des tableaux, jamais évoqué en formation. La figure initiale avait néanmoins un défaut : elle produisait un seul résultat. Si on lançait deux fois le script, cela recréait tous les points (donc avec des * comme Moy*, Med*, etc, selon le fonctionnement de CaRMetal, ce qu’il fallait modifier).

D’où la proposition d’une réécriture pour que cela ne se passe pas ainsi (et celle de faire 5 tirages par script lancé pour vérifier).

Ce que ne dit pas la stagiaire dans son explication est donc que, suite à cette réécriture minimale (on ne change que l’affectation des points calculés) l’on ne part pas d’une figure vide, mais au contraire d’une figure initialisée avant le lancer du script, avec tous les points déjà construits : c’est pour cela que l’on n’utilise que la fonctionnalité Move car on déplace des points déjà créés.

La figure initiale :

Si la figure est basique dans sa forme, pour un premier script, elle est intéressante. Elle mériterait d’être un peu plus habillée.

D’une manière générale, les scripts sont très efficaces pour les statistiques, que ce soit en collège ou en lycée. On en trouvera dans les forums de CaRMetal à ce topic, mais aussi à cette page d’un collègue. Un article plus technique, sur les coïncidences des anniversaires, propose une méthode générale de scripts pour permettre une manipulation directe maximale aux paramètres en jeu,

Étoiles animées

Réalisé par Frédéric BELLON, Cécile DAMBREVILLE et Olivier PAYET

On termine cette présentation par le script le plus fun, sans lien direct avec un thème scolaire. Il propose un travail sur les polygones étoilés en les animant. Le script fait cette figure :

Ci-dessus, la figure est faite avec des heptagones, mais on peut changer la valeur du nombre de côtés n dans le script.

Aspect technique

Ce script a été fait avec la version 3.1.1. Dans cette version, l’animation des points était différente : on pouvait animer un point libre sur un objet. Ce n’est plus le cas. (Détails sur les animations de la version 3.5.)

Il faut donc, une fois le script effectué, attacher l’unique point visible au cercle (auquel on pourrait penser qu’il appartient), par Clic-droit sur le point et « Attacher » :

Détail du script, largement commenté par son auteur

// nombre de branche de l'étoile
n=7;
// rayon de l'étoile initiale
R=2;
angle=360/n;
Point("O",0,0);
Point("A",R,0);SetPointType("A","circle");
SetHide("O",true);
FixedCircle("O",R);
// compteur de sommets, de centres et de segments
b=1;
c=1;
t=1;
// détermination des sommets de l'étoile initiale
for (i=1; i<2*n; i=i+1){
	a=(i-1)*angle;
	Point("A"+b,"(x(A)-x(O))*cos(_a)-(y(A)-y(O))*sin(_a)","(x(A)-x(O))*sin(_a)+(y(A)-y(O))*cos(_a)");
	SetHide("A"+b,true);
	b=b+1;
}
k=Math.floor(n/2)
// on trace l'étoile
for (i=1; i<n+1; i=i+1){
	j=i+k+1;
	s_t=Segment("A"+i,"A"+j);
	SetRGBColor(s_t,100,(255/n)*i,230);
	t=t+1;
}
// détermination des centres des étoiles entourant
for (i=1; i<2*n; i=i+1){
	a=(i-1)*angle;
	Point("O"+c,"1.35*_R*cos(_a)","1.35*_R*sin(_a)");
	SetHide("O"+c,true);
	c=c+1;
}

// de la même façon on trace les autres étoiles
for (m=1; m<n+1; m=m+1){
	for (i=1; i<2*n; i=i+1){
		Point("A"+b,"x(O_m)-0.35*(x(A_i)-x(O))","y(O_m)-0.35*(y(A_i)-y(O))");
		SetHide("A"+b,true);
		b=b+1;
	}
	for (i=1; i<n+1; i=i+1){
		s=b-2*n+i;
		j=k+1+s;
		s_t=Segment("A"+s,"A"+j);
		SetRGBColor(s_t,(255/n)*i,230,100);
		t=t+1;
	}
	for (i=1; i<2*n; i=i+1){
		a=(i-1)*angle;
		j=(m-1)*angle;
		Point("O"+c,"1.35*_R*cos(_j)-(0.35+0.35*0.35)*_R*cos(_a)","1.35*_R*sin(_j)-(0.35+0.35*0.35)*_R*sin(_a)");
		SetHide("O"+c,true);
		c=c+1;
	}
}
for (p=1; p<n+1; p=p+1){
	for (m=1; m<n+1; m=m+1){
		h=p*(2*n-1)+p;
		for (i=1; i<2*n; i=i+1){
			j=i+(2*n-1)*m;
			Point("A"+b,"x(O_h)-0.35*(x(A_j)-x(O_p))","y(O_h)-0.35*(y(A_j)-y(O_p))");
			SetHide("A"+b,true);
			b=b+1;
		}
		for (i=1; i<n+1; i=i+1){
			s=i+b-2*n;
			j=k+1+s;
			s_t=Segment("A"+s,"A"+j);
			SetRGBColor(s_t,230,100,(255/n)*i);
			t=t+1;
		}
	}
}