Pour explorer DGPad : tableaux de fils « géométriques »

lundi 25 mars 2013
par  Alain BUSSER , Yves MARTIN

On se propose de faire des tableaux de fils dynamiques avec le nouveau logiciel de Eric Hakenholz, DGPad, sans utiliser d’expression comme on le ferait dans CaRMetal ou dans Geogebra. Voici quelques idées qui sont autant d’explorations intéressantes de la façon dont on apprend à s’adapter à des contraintes pour produire ce que l’on veut réaliser.

Le logiciel de géométrie dynamique DGPad est un logiciel pour tablettes, mais qui fonctionne aussi sur ordinateur. Au moment où cet article est écrit, c’est une webapp, donc qui ne fonctionne qu’en ligne. Elle est néanmoins destinée à devenir rapidement une application autonome après les premiers retours d’utilisateurs.

Quelques précisions techniques

Sous Android il faut utiliser Firefox, sous iOS, Chrome ou Safari.

Sur ordinateur, on peut glisser les fichiers .txt proposés au téléchargement dans cet article, sur la fenêtre principale de l’application (du navigateur). Sur tablette, soit on dispose d’un système de gestion de fichiers, soit on utilise un nuage comme DropBox ou autres.

Le fonctionnement des outils contextuels, fait pour tablettes, est suffisamment original pour fortement conseiller de regarder au moins les premières vidéos de présentation sur le site de DGPad avant de se servir de l’application.

Un tour d’horizon assez large du logiciel, une première analyse de ses choix et une présentation de ses possibilités techniques sera proposée de manière structurée dans le numéro 35 de MatheMATICE (mai 2013).

La problématique de l’article

Mais, en attendant, les auteurs de cet article souhaitaient montrer quelques unes de ses possibilités dans le cadre de cette question : comment pourrait-on faire des tableaux de fils dynamiques avec ce logiciel naissant qui, certes, a des macros, mais n’a pas encore d’expressions algébriques disponibles directement dans l’interface utilisateur ?

On suppose que le lecteur a déjà joué à cela, soit par exemple avec les séquences de Geogebra, soit encore avec les CaRScripts de CaRMetal (comme on l’a déjà fait ici - premier onglet)

C’est bien entendu un prétexte pour parler des scripts (naturellement disponibles dans DGPad puisque le logiciel est entièrement écrit en JavaScript) et même de l’utilisation de fonctions récursives ...

En toile de fond [1] c’est aussi une illustration de nos capacités, comme enseignants, à adapter nos techniques usuelles (nos schèmes d’action et nos réflexes culturels) à un nouvel environnement, qui a - temporairement - d’autres contraintes que celles que l’on connaît d’habitude et pour lequel nos pratiques spontanées ne peuvent s’appliquer.

Comme les figures s’exportent très facilement, elles seront - pas toujours mais souvent - dans le corps du texte.

Nous allons voir 4 méthodes :

• Une technique de lieu de segments, dans laquelle on ne fait que donner la main au logiciel.
• Une méthode utilisant le nommage de points : c’est la première réellement efficace, mais assez subtile à mettre en œuvre. Son algorithme mérite d’être regardé de près et peut être utilisé dans différentes situations (comme en ISN probablement).
• Une méthode qui veut éviter le nommage des points (d’où la récursivité).
• Un retour à la géométrie, en construisant des graduations : plus flexible que les deux précédentes, mais plus gourmande en points.

1. Comme lieu

Tableaux de fils comme lieu de segments.

Ce premier onglet est aussi l’occasion de montrer rapidement le fonctionnement du logiciel aux personnes qui ne l’ont pas encore utilisé.

Tracé des deux segments

On construit trois points, puis on les joint par deux segments. Pour cela, on sélectionne un des points :

On constate que la palette d’outils qui apparaît, correspond à tout ce qu’on peut faire subir à ce point ; on choisit le segment. Mais on ne doit pas relâcher l’outil sinon on aurait la création d’un autre point au hasard : Au contraire, on fait glisser l’outil de construction

jusqu’à l’autre extrémité :

On fait pareil pour construire l’autre segment (horizontal).

Construction d’un point sur segment

Pour attacher un point au segment, on sélectionne celui-ci :

On choisit alors le premier outil de la palette (le point) :

Report de longueur

On veut reporter la longueur allant de l’extrémité haute du segment au point mobile, depuis l’extrémité basse du segment. Le point de départ de cette construction étant l’extrémité haute du segment, on le sélectionne, et là, l’outil de report de longueur :

On fait glisser cet outil vers l’autre point définissant la longueur à reporter :

puis on fait glisser le même outil vers l’origine du repère [2] :

Tendre le fil

On veut que la longueur reportée soit sur le segment horizontal : Pour cela on construit l’intersection du cercle juste construit et dudit segment ; on le fait par sélection simultanée des deux objets :

Puis on choisit l’outil « point » :

Enfin on joint ce point au point mobile par un segment :

Figure finale

Comme le segment qu’on vient de construire dépend d’un point sur segment, il possède un nouvel outil « lieu » :

Il suffit alors d’activer cet outil pour finir la figure.

La voici : On peut vérifier en bougeant l’un des trois points, qu’on a toujours une conique (en fait une parabole) :

On voit que l’enveloppe tracée est celle de droites, pas de segments, et qu’on n’a aucun contrôle sur le nombre de fils tendus. Donc on va essayer, dans les onglets suivants, de faire un tableau de fils bornés.

Retour à la barre d’onglets

2. Par nommage de points

Algorithme de nommage séquentiel des points obtenus par milieux itérés

Principe : Comme on ne dispose pas de possibilité de traitement d’un pas de subdivision d’un segment, une méthode consiste à utiliser des milieux successifs. Dans cette approche, on se limite à des partages des segments en un nombre qui est une puissance de 2, en pratique, 16 ou 32.
Or, si on envisage de partager un segment en 16, le premier milieu sera le 8° point, puis les suivants les 4° et 12° ... et il faut donc les nommer en conséquence
.

L’algorithme consiste à relier le point A1 au point B15, le point A2 au point B14 etc. Il faut donc que les points A1, A2 etc soient alignés dans cet ordre, ainsi que les points B1 à B16. Les points A1, A2 ... A15 seront construits par milieux, et les points O (qui remplace à la fois A0 et B0), A16 et B16 seront construits d’avance sur la figure, ainsi que les segments [OA16] et [OB16]

Construction pré-JavaScript

On construit donc dans DGPad, et on renomme, les objets en question :

Puis on exporte la figure en choisissant le mode texte :

Exemple de code obtenu

C’est du JavaScript :

// Coordinates System :
SetCoords(420,315,5);


// Geometry :
O=Point("O",-58.6,24.5);
A16=Point("A16",-33.4,25.9);
B16=Point("B16",-54.6,52.8);
S1=Segment("S1",O,B16);
S2=Segment("S2",O,A16);


// Styles :
STL(O,"c:#0000b2;s:6;sn:true;f:30");
STL(A16,"c:#0000b2;s:6;sn:true;f:30");
STL(B16,"c:#0000b2;s:6;sn:true;f:30");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

On constate que pour que le nom d’un point soit affiché, on lui donne la propriété sn : true [3]. De même, on peut cacher un point en lui donnant le style h:1 [4]. On le fera ci-dessous. On remarque que la syntaxe des styles est très proche de celle des feuilles de style en cascade.

Enfin on sauvegarde le résultat sous le nom tableau_fils.txt [5]. La suite des opérations se fera dans un éditeur de texte [6], sous la forme d’un programme JavaScript à ajouter dans le fichier obtenu.

Pour charger un fichier, on clique sur l’icône représentant une flèche sortant d’un nuage (car DGPad est basé sur le Cloud computing, et tout fichier est considéré comme placé sur le Cloud), et on sélectionne le fichier tableau_fils.txt avec l’outil filepicker.io qui apparaît alors.

Algorithme de tracé et nommage des points

Les points étant définis comme des milieux, il est nécessaire avant de construire l’un d’entre eux, que les extrémités du segment dont il est le milieu soient préalablement construites. La relation « est milieu de » est représentée par un arbre binaire construit en profondeur mais dont les sommets sont nommés en largeur. Le meilleur moyen de construire la double boucle qui réalise cela, est de commencer par la fin : Les derniers milieux construits seront A1, A3, A5 etc parce que les milieux d’indice pair auront tous été déjà construits. On les parcourra donc par pas de 2, en commençant par 1. Au stade précédent, on construira A2, A6, A10 et A14 parce que les autres milieux auront déjà été construits auparavant : Par pas de 4, en commençant par le premier d’entre eux.

Donc le pas est une suite géométrique de raison 1/2, de premier terme 16. Et dans cette boucle sur le pas, les points sont parcourus pas par pas, en commençant par la moitié du pas :

for(pas=16; pas>1; pas/=2){
        for(n=pas/2; n<16; n+=pas){
                a=n-pas/2;
                if (a==0) {a="O"} else {a="A"+a;}
                b=n+pas/2;
                b="A"+b;
                MidPoint("A"+n,a,b);
        }
}

Diverses additions

Dans la seconde ligne « for », n+=pas additionne le pas à la valeur courante de n ; les créations des variables a et b font de même, en soustrayant ou additionnant la moitié du pas à n. Mais dans le test et dans les deux dernières affectations, l’addition désigne la concaténation entre chaînes de caractères : JavaScript convertit automatiquement les nombres en texte parce que le premier terme de l’addition n’est visiblement pas un nombre (il est entre guillemets) et donc le second est censé être lui aussi traité comme du texte. C’est ainsi que se fait le nommage automatique des points.

Le premier point définissant le premier milieu ne s’appelant pas A0 mais 0, il a fallu ajouter un test pour régler ce cas.

La figure complète à ce stade

Avec ce qui précède, on obtient ceci (on peut supprimer la dernière ligne sans problème, elle sera reconstruite par DGPad) :

// Coordinates System :
SetCoords(420,315,5);


// Geometry :
O=Point("O",-58.6,24.5);
A16=Point("A16",-33.4,25.9);
B16=Point("B16",-54.6,52.8);
S1=Segment("S1",O,B16);
S2=Segment("S2",O,A16);


// Styles :
STL(O,"c:#0000b2;s:6;sn:true;f:30");
STL(A16,"c:#0000b2;s:6;sn:true;f:30");
STL(B16,"c:#0000b2;s:6;sn:true;f:30");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");


for(pas=16; pas>1; pas/=2){
        for(n=pas/2; n<16; n+=pas){
                a=n-pas/2;
                if (a==0) {a="O"} else {a="A"+a;}
                b=n+pas/2;
                b="A"+b;
                MidPoint("A"+n,a,b);
        }
}

En chargeant cette figure dans DGPad, on vérifie que les points portent bien le nom attendu ; on va ensuite ajouter dans la boucle un effet de style pour cacher les points A1, A2, etc.

Une boucle similaire permet de construire et nommer les points B1, B2, B3 etc. Chaque fois, au fur et à mesure, on met h:1 dans leur style pour les cacher.

Tendre les fils

Maintenant ça devient facile : On joint le point A15 au point B1, le point A14 au point B2, etc. Donc on joint le point A(16-n) au point Bn dans une boucle sur n :

for(n=1; n<16; n++){
        Segment("A"+(16-n),"B"+n);
}

fichiers obtenus

Voici le fichier de construction de la figure ci-dessous :

// Coordinates System :
SetCoords(420,315,5);


// Geometry :
O=Point("O",-58.6,24.5);
A16=Point("A16",-33.4,25.9);
B16=Point("B16",-54.6,52.8);
S1=Segment("S1",O,B16);
S2=Segment("S2",O,A16);


// Styles :
STL(O,"c:#0000b2;s:6;f:30");
STL(A16,"c:#0000b2;s:6;f:30");
STL(B16,"c:#0000b2;s:6;f:30");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");


for(pas=16; pas>1; pas/=2){
        for(n=pas/2; n<16; n+=pas){
                a=n-pas/2;
                if (a==0) {a="O"} else {a="A"+a;}
                b=n+pas/2;
                b="A"+b;
                m=MidPoint("A"+n,a,b);
                STL(m,"h:1");
                a=n-pas/2;
                if (a==0) {a="O"} else {a="B"+a;}
                b=n+pas/2;
                b="B"+b;
                m=MidPoint("B"+n,a,b);
                STL(m,"h:1");
        }
}

for(n=1; n<16; n++){
        Segment("A"+(16-n),"B"+n);
}


Et voici le fichier traduit par DGPad :

// Coordinates System :
SetCoords(420,315,5);


// Geometry :
O=Point("O",-58.6,24.5);
A16=Point("A16",-33.4,25.9);
B16=Point("B16",-54.6,52.8);
S1=Segment("S1",O,B16);
S2=Segment("S2",O,A16);
A8=MidPoint("A8",O,A16);
B8=MidPoint("B8",O,B16);
A4=MidPoint("A4",O,A8);
B4=MidPoint("B4",O,B8);
A12=MidPoint("A12",A8,A16);
B12=MidPoint("B12",B8,B16);
S10=Segment("S10",A8,B8);
A2=MidPoint("A2",O,A4);
B2=MidPoint("B2",O,B4);
A6=MidPoint("A6",A4,A8);
B6=MidPoint("B6",B4,B8);
A10=MidPoint("A10",A8,A12);
B10=MidPoint("B10",B8,B12);
A14=MidPoint("A14",A12,A16);
B14=MidPoint("B14",B12,B16);
S6=Segment("S6",A12,B4);
S14=Segment("S14",A4,B12);
A1=MidPoint("A1",O,A2);
B1=MidPoint("B1",O,B2);
A3=MidPoint("A3",A2,A4);
B3=MidPoint("B3",B2,B4);
A5=MidPoint("A5",A4,A6);
B5=MidPoint("B5",B4,B6);
A7=MidPoint("A7",A6,A8);
B7=MidPoint("B7",B6,B8);
A9=MidPoint("A9",A8,A10);
B9=MidPoint("B9",B8,B10);
A11=MidPoint("A11",A10,A12);
B11=MidPoint("B11",B10,B12);
A13=MidPoint("A13",A12,A14);
B13=MidPoint("B13",B12,B14);
A15=MidPoint("A15",A14,A16);
B15=MidPoint("B15",B14,B16);
S4=Segment("S4",A14,B2);
S8=Segment("S8",A10,B6);
S12=Segment("S12",A6,B10);
S16=Segment("S16",A2,B14);
S3=Segment("S3",A15,B1);
S5=Segment("S5",A13,B3);
S7=Segment("S7",A11,B5);
S9=Segment("S9",A9,B7);
S11=Segment("S11",A7,B9);
S13=Segment("S13",A5,B11);
S15=Segment("S15",A3,B13);
S17=Segment("S17",A1,B15);


// Styles :
STL(O,"c:#0000b2;s:6;f:30");
STL(A16,"c:#0000b2;s:6;f:30");
STL(B16,"c:#0000b2;s:6;f:30");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
STL(A8,"c:#0000b2;h:1;s:6;f:30");
STL(B8,"c:#0000b2;h:1;s:6;f:30");
STL(A4,"c:#0000b2;h:1;s:6;f:30");
STL(B4,"c:#0000b2;h:1;s:6;f:30");
STL(A12,"c:#0000b2;h:1;s:6;f:30");
STL(B12,"c:#0000b2;h:1;s:6;f:30");
STL(S10,"c:#006633;s:1;f:24");
STL(A2,"c:#0000b2;h:1;s:6;f:30");
STL(B2,"c:#0000b2;h:1;s:6;f:30");
STL(A6,"c:#0000b2;h:1;s:6;f:30");
STL(B6,"c:#0000b2;h:1;s:6;f:30");
STL(A10,"c:#0000b2;h:1;s:6;f:30");
STL(B10,"c:#0000b2;h:1;s:6;f:30");
STL(A14,"c:#0000b2;h:1;s:6;f:30");
STL(B14,"c:#0000b2;h:1;s:6;f:30");
STL(S6,"c:#006633;s:1;f:24");
STL(S14,"c:#006633;s:1;f:24");
STL(A1,"c:#0000b2;h:1;s:6;f:30");
STL(B1,"c:#0000b2;h:1;s:6;f:30");
STL(A3,"c:#0000b2;h:1;s:6;f:30");
STL(B3,"c:#0000b2;h:1;s:6;f:30");
STL(A5,"c:#0000b2;h:1;s:6;f:30");
STL(B5,"c:#0000b2;h:1;s:6;f:30");
STL(A7,"c:#0000b2;h:1;s:6;f:30");
STL(B7,"c:#0000b2;h:1;s:6;f:30");
STL(A9,"c:#0000b2;h:1;s:6;f:30");
STL(B9,"c:#0000b2;h:1;s:6;f:30");
STL(A11,"c:#0000b2;h:1;s:6;f:30");
STL(B11,"c:#0000b2;h:1;s:6;f:30");
STL(A13,"c:#0000b2;h:1;s:6;f:30");
STL(B13,"c:#0000b2;h:1;s:6;f:30");
STL(A15,"c:#0000b2;h:1;s:6;f:30");
STL(B15,"c:#0000b2;h:1;s:6;f:30");
STL(S4,"c:#006633;s:1;f:24");
STL(S8,"c:#006633;s:1;f:24");
STL(S12,"c:#006633;s:1;f:24");
STL(S16,"c:#006633;s:1;f:24");
STL(S3,"c:#006633;s:1;f:24");
STL(S5,"c:#006633;s:1;f:24");
STL(S7,"c:#006633;s:1;f:24");
STL(S9,"c:#006633;s:1;f:24");
STL(S11,"c:#006633;s:1;f:24");
STL(S13,"c:#006633;s:1;f:24");
STL(S15,"c:#006633;s:1;f:24");
STL(S17,"c:#006633;s:1;f:24");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");


Le tableau de fils ainsi construit est bien dynamique, comme on peut le vérifier en bougeant un des trois points :


Retour à la barre d’onglets

3. Par récursivité

Utiliser la récursivité pour ne pas nommer les points

En terme de modification de nos schèmes d’action, l’onglet précédent, avec son algorithme sur l’arbre des milieux parcouru en profondeur dont les sommets sont nommés en largeur, nous avons été bien servis.

Mais c’est aussi un très bon plat, et dans un cours d’algorithmique c’est même un plat de résistance qui peut être resservi, au moins pour analyse de ce qu’il fait ... et ce pourrait être l’occasion de présenter aussi un logiciel de géométrie dynamique à l’interface tactile innovante ...

Le principe

Dans cet onglet, on se propose d’observer que, puisque le meilleur moyen de parcourir un arbre en profondeur est de le faire récursivement, la récursivité permet de simplifier considérablement le script ; cerise sur le gâteau (celui qui vient juste après le plat de résistance), l’algorithme récursif suivant permet également de se passer du parcours en largeur (du nommage des points).

L’algorithme de partage par les milieux successifs peut être perçu autrement que dans « la recherche de la largeur », il est même essentiellement récursif :


Étant donnés deux segments [OA] et [OB],
• on prend les milieux, I et J
• on applique la démarche, de manière récursive, sur [IA] et [OJ], puis sur [OI] et [JB].

On voit que la fonction récursive doit tenir compte de quatre points initiaux et non pas trois. Elle est très simple à écrire, il suffit de traduire en JavaScript ce qui précède :

function fils(a1,a2,b1,b2,k){       
                var m1=MidPoint(a1,a2); STL(m1,"h:1");var n1=MidPoint(b1,b2);        

STL(n1,"h:1");
                Segment(m1,n1);
        if (k>0) {fils(m1,a2,b1,n1,k-1); fils(a1,m1,n1,b2,k-1);}                               
}

fils(O,A,O,B,4);


Et pour trois points on applique la fonction avec deux points confondus, comme ci-dessus, ce qui donne cette figure pour un partage des segments en 32 (copie d’écran) :


Applications immédiates

Ceci étant fait, on peut enrichir la fonction fil d’une couleur, et l’appliquer à des figures régulières comme dans ces exemples (manipulables à la souris ou au doigt).


Le script de cette figure (que l’on peut copier-coller)

// Coordinates System :
SetCoords(450.79391315405485,329.5035948619152,0.6363304158669557) ;

// Geometry :
O=Point(« O »,45.897675354955176,36.936148698617814) ;
A=Point(« A »,-203.9725116348866,132.79829590855712) ;
C1=Circle(« C1 »,O,A) ;
C=Symmetry(« C »,O,A) ;
S1=Segment(« S1 »,C,A) ;
S7=Segment(« S7 »,A,C) ;
Perp1=Perpendicular(« Perp1 »,S1,O) ;
D=OrderedIntersection(« D »,Perp1,C1,1) ;
B=OrderedIntersection(« B »,Perp1,C1,0) ;
S2=Segment(« S2 »,B,C) ;
S3=Segment(« S3 »,C,D) ;
S4=Segment(« S4 »,D,A) ;
S5=Segment(« S5 »,A,B) ;
S6=Segment(« S6 »,B,D) ;
bleuclair=« c :#0044ff » ;
rouge=« c :#b40000 » ;
vertfluo=« c :#1df40d » ;

// Styles :
STL(O,« c :#0000b2 ;o:1 ;s:6 ;sn:true ;f:20 ») ;
STL(A,« c :#0000b2 ;o:1 ;s:6 ;sn:true ;f:20 ») ;
STL(C1,« c :#cc66cc ;h:1 ;s:1 ;f:30 ;p:0 ») ;
STL(C,« c :#0000b2 ;s:6 ;sn:true ;f:20 ») ;
STL(S1,« c :#006633 ;h:1 ;s:1 ;f:24 ») ;
STL(S7,« c :#0000b2 ;h:1 ;s:1.5 ;f:24 ») ;
STL(Perp1,« c :#0000b2 ;h:1 ;s:1 ;f:30 ;p:0 ») ;
STL(D,« c :#0000b2 ;s:6 ;sn:true ;f:20 ») ;
STL(B,« c :#0000b2 ;s:6 ;sn:true ;f:20 ») ;
STL(S2,« c :#0000b2 ;s:1 ;f:24 ») ;
STL(S3,« c :#0000b2 ;s:1 ;f:24 ») ;
STL(S4,« c :#0000b2 ;s:1 ;f:24 ») ;
STL(S5,« c :#0000b2 ;s:1 ;f:24 ») ;
STL(S6,« c :#0000b2 ;h:1 ;s:1 ;f:24 ») ;
SetCoordsStyle(« isAxis:false ;isGrid:true ;isOx:true ;isOy:true ;isLockOx:false ;isLockOy:false ;color :#111111 ;fontSize:18 ;axisWidth:1 ;gridWidth:0.1 ») ;

function fils(a1,a2,b1,b2,LaCouleur,k)
var m1=MidPoint(a1,a2) ; STL(m1,« h:1 ») ;var n1=MidPoint(b1,b2) ; STL(n1,« h:1 ») ;
LeSeg=Segment(m1,n1) ;STL(LeSeg,LaCouleur) ;
if (k>0) fils(m1,a2,b1,n1,LaCouleur,k-1) ;fils(a1,m1,n1,b2,LaCouleur,k-1) ;

n=4 ;
fils(B,A,B,C,bleuclair,n) ;fils(C,B,C,D,bleuclair,n) ;fils(D,C,D,A,bleuclair,n) ;fils(A,D,A,B,bleuclair,n) ;


D’autres exemples sont proposés en téléchargement en fin d’article comme celui-ci (copie d’écran) :


Et, toujours sans expression, de manière uniquement géométrique, on peut même ajouter un curseur : il fait tourner la construction intérieure bleue dans la plus grande, recyclage géométrique de ce qui est fait, de manière analytique dans cet article à l’onglet « fun » (toujours en copie d’écran) :



Utilisation des figures en téléchargement

Quand on charge des figures comme celles-ci, dans la version disponible au moment de la rédaction de cet article, on ne voit pas la figure se construire peu à peu - comme ce serait le cas avec des CarScripts - mais seulement à la fin de l’exécution du script, ce qui peut prendre quelques secondes.

Retour à la barre d’onglets

4. Avec la géométrie

Retour à une construction plus classique

Avec Thalès, on peut subdiviser un segment en autant de subdivisions qu’on veut, ce qui permet de faire des tableaux de fils classiques à 10 points au lieu des puissances de 2 nécessaires dans les onglets précédents :

Le début est le même que dans l’onglet 2, sauf que les extrémités des segments ne s’appellent plus A16 et B16, mais A10 et B10. DGPad a nommé automatiquement S1 et S2 les deux segments ; on en aura besoin plus bas pour les intersections.

Graduation auxiliaire

On crée une graduation par des symétries centrales itérées ; le début de la graduation est O, le point suivant s’appelle C1, et C2 est défini comme symétrique de O par rapport à C1 ; ensuite, le point Cn est le symétrique de C(n-2) par rapport à C(n-1) :

Projection des graduations sur [OA10]

Ensuite, on joint le point C10 au point A10 par une droite, et les parallèles à cette droite par les points Cn coupent le segment S1 en les points An :

Ces points A1, A2, A3 etc sont cachés, ainsi que les parallèles, pour laisser voir le tableau de fils :

Projection des graduations sur [OB10]

On fait pareil, avec les mêmes points auxiliaires Cn, pour construire les points Bn :

Tendre les fils

Comme précédemment :

Le script complet

// Coordinates System :
SetCoords(512,286,40);


// Geometry :
O=Point("O",-9.375,0.725);
A10=Point("A10",-5.875,1.275);
B10=Point("B10",-8.7,3.825);
C1=Point("C1",-8.325,1.75);
S1=Segment("S1",O,A10);
S2=Segment("S2",O,B10);

C2=Symmetry("C2","C1","O");
STL(C2,"h:1");
for(var n=3; n<=10; n++){
        c=Symmetry("C"+n,"C"+(n-1),"C"+(n-2));
        STL(c,"h:1");
}

dA=Line("dA10","C10","A10");
STL(dA,"h:1");
for(var n=1; n<10; n++){
        d=Parallel("dA"+n,"dA10","C"+n);
        STL(d,"h:1");
        a=OrderedIntersection("A"+n,S1,d,0);
        STL(a,"h:1");
}
dB=Line("dB10","C10","B10");
STL(dB,"h:1");
for(var n=1; n<10; n++){
        d=Parallel("dB"+n,"dB10","C"+n);
        STL(d,"h:1");
        b=OrderedIntersection("B"+n,S2,d,0);
        STL(b,"h:1");
}

for(n=1; n<10; n++){
        Segment("A"+(10-n),"B"+n);
}


// Styles :
STL(O,"c:#0000b2;s:6;sn:true;f:18");
STL(A10,"c:#0000b2;s:6;sn:true;f:18");
STL(B10,"c:#0000b2;s:6;sn:true;f:20");
STL(C1,"c:#0000b2;h:1;s:6;sn:true;f:30");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

Et hop : Un tableau de fils dynamique à 10 fils :


[1c’est le cas de le dire...

[2le fil à la patte aide à comprendre comment ça fonctionne

[3sn est une abréviation de « show name ».

[4h comme « hide »

[5L’extension est txt mais le fichier est bien du JavaScript. Le gestionnaire filepicker.io refuse les fichiers ayant l’extension js.

[6astuce sous Gedit : Bien que le fichier ait l’extension txt on peut choisir la coloration syntaxique JavaScript qui en améliore grandement la lisibilité.


Documents joints

Texte - 702 octets
Texte - 702 octets
La figure à charger dans DGPad
Zip - 48 ko
Zip - 48 ko
Fichiers Scripts onglet 3

Commentaires

Annonces

Prochains rendez-vous de l’IREM

Séminaire EDIM-IREM

- Mercredi 22 novembre 2017, 14h-18h, campus du Tampon, amphi 120 D
- Mercredi 7 février 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 7 mars 2018, 14h-18h, campus du Tampon
- Mercredi 4 avril 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 2 mai, 14h-18h, campus du Tampon
- Mardi 5 juin 2018, PTU, Saint-Denis, salle S23.6
- Mercredi 6 juin, 14h-18h, campus du Tampon

Fête de la science

Campus du Moufia, 16 et 17 novembre 2017.
Thème : « La recherche à l’heure du numérique »

Semaine des mathématiques

Du 26 au 31 mars 2018.
Thème : « Mathématiques et mouvement »


Brèves

DGPad à Limoges

mercredi 19 avril

L’IREM de Limoges a réussi à inscrire au P.A.F. une journée de présentation de DGPad ; la tortue y a eu un franc succès. Voici le compte-rendu. Il y a des ressources à réinvestir en classe, n’hésitez pas à y puiser !

DGPad sur MathémaTICE

lundi 20 mai 2013

La révolution tactile, toute naissante, en est probablement à ses premiers balbutiements. Et pourtant, ses premières réalisations contiennent déjà de petits bijoux. C’est le cas, pour ce qui est de la géométrie dynamique, de DGPad. En deux articles sur MathémaTICE, Yves Martin propose un vaste tour d’horizon de cette nouvelle application.

Sur le Web : DGPad sur MathémaTICE

Périmètre, aire et volume au collège

lundi 16 janvier 2012

Myriam Bouloc Rossato et Jean-Jacques Dahan ont conçu un scénario interactif pour enseigner les notions de périmètre, d’aire et de volume au collège à l’aide de la géométrie dynamique (Cabri 2Plus et Cabri 3D). Le document s’appuie sur des figures animables en ligne et sur des vidéos postées sur YouTube.

Sur le Web : Document interactif

Le théorème d’Ayme

dimanche 4 décembre 2011

Notre collègue Jean-Louis Ayme est à l’honneur : il vient de publier un nouveau théorème, le « théorème d’Ayme » ou « théorème des quatre points ».

Deux nouveaux points remarquables du triangle, les points X3610 et X3611, lui ont été attribués - ainsi qu’à Peter Moses - par Clark Kimberling dans son Encyclopedia of Triangle Centers.

Sur le Web : Le théorème d’Ayme

Geometry Géométrie Geometria

mercredi 2 novembre 2011

Geometry Géométrie Geometria est un site extrêmement riche réalisé par Jean-Louis Ayme : entièrement consacré à la géométrie du triangle, il mérite d’être visité longuement.

On pourra lire notamment le très attrayant volume 20 sur les cercles inscrits égaux, qui fait écho à des articles déjà publiés sur le site de l’IREM.

Statistiques

Dernière mise à jour

lundi 20 novembre 2017

Publication

774 Articles
Aucun album photo
133 Brèves
11 Sites Web
132 Auteurs

Visites

712 aujourd'hui
1449 hier
2167738 depuis le début
50 visiteurs actuellement connectés