DGPad : la géométrie dynamique à l’ère du numérique

mardi 18 mars 2014
par  Yves MARTIN

DGPad est une application de géométrie dynamique, récente. Écrite pour tablettes, elle est aussi disponible en webApp pour les ordinateurs, ce qui permet d’accompagner la migration de l’ordinateur vers la tablette. Elle permet aussi des mises en ligne rapides (dans un ENT par exemple). Après avoir examiné les choix ergonomiques de l’auteur, cet article fait un tour d’horizon approfondi des possibilités actuelles de cette application.

DGPad, qui a déjà dix mois d’existence, a bien progressé depuis les premières présentations de mai 2013. Cette présentation est construite en trois parties :

Son interface générale et les éléments géométriques associés.
Son mode calculatrice avec les expressions algébriques, le traceur de courbes, les curseurs et ses listes de points ou d’expressions.
Sa gestion de la 3D.

L’article est construit sur la base de trois barres de menue, une par partie. On peut changer de barre de menu à la fin de chaque onglet.

Pour donner un rapide aperçu de ce que l’on peut réaliser avec DGPad, voici une présentation dynamique des patrons d’un cube avec choix croisé du patron et du pliage par deux curseurs.
Modifier le trièdre : « clic-droit glisser » à la souris sur ordinateur, deux doigts sur tablette.


On donnera souvent des liens externes aux figures pour les manipuler dans un écran plus large que ce que permet l’environnement SPIP du site.
Pour manipuler cette figure dans une fenêtre externe, utiliser ce lien : goo.gl/ea8psJ

À propos du code JavaScript
Pour les personnes qui veulent approfondir la pratique du logiciel, des explications sont données - dernier onglet de la partie 1 et quelques onglets de la partie 2 - avec interprétation du code JavaScript.
En le colorisant, il est apparu un bouton « télécharger ». Mais a priori ce sont des extraits de figure, il n’y a rien d’intéressant à télécharger en général.

1. Interface générale de DGPad - Aspect géométrique - Macros - Format de fichiers


Question d’interface

1.1.a. Quelles valeurs se dégagent de la géométrie dynamique

La géométrie dynamique, comme culture de la manipulation directe, a déjà une histoire : depuis Cabri-géomètre en France, Cinderella en Allemagne - pour citer les équipes de développement les plus avancées dans leurs réflexions, la géométrie dynamique a véhiculé certaines valeurs spécifiques, auxquelles ont plus ou moins adhéré les autres logiciels selon les implications didactiques de leurs auteurs.

La première de ces valeurs est l’anticipation des objets lors de leur création : pour une meilleure réification des objets géométriques modélisés - typiquement quand on crée un segment, une droite, un cercle - la construction est anticipée et suit le mouvement de la souris, le dernier clic étant une confirmation de cette anticipation. Renée Grothman a étendu, dans son logiciel CaR, cette règle d’anticipation à tous les objets, non seulement de création mais aussi de construction, y compris dans ses macro-constructions. La reprise de CaR dans l’interface CaRMetal a popularisé cette généralisation de l’anticipation des constructions.

La deuxième des valeurs fortement soutenue par Jean Marie Laborde (Cabri-géométre) et Ulrich Kortenkamp (Cinderella) est la notion de micro-monde : pour eux, un logiciel de géométrie dynamique se doit de disposer d’un procédé de macro-constructions qui permet d’enrichir le logiciels du travail fait par les utilisateurs.

Une autre valeur importante est celle de l’engagement direct, que Jean Marie Laborde définie comme la reconnaissance par le logiciel du savoir de l’utilisateur sur les objets qu’il manipule. L’engagement direct des logiciels peut être visuel dans l’interface, comme la prise à la volée de l’intersection de deux droites ou de deux segments sans que l’outil intersection soit choisi - et le retour visuel que cette intersection a bien été prise en compte. Mais c’est aussi la distinction des deux intersections d’une droite et d"un cercle ou de deux cercles par exemple quand l’utilisateur ne choisit qu’une deux deux intersections. Il y a tout un travail interne au logiciel pour maintenir le suivi continu de ces intersections.

On a déjà présenté à l’IREM cette problématique entre le déterminisme des figures (la figure doit revenir dans son état initial quand ses points de base reviennent à leur état initial), et le suivi continu des intersections. On sait que, d’un point de vue théorique, les deux sont fondamentalement incompatibles et il faut donc développer des trésors d’ingéniosité algorithmique pour maintenir le premier point tout en assurant le plus possible le second. On sait que ces aspects là sont bien développés dans Geogebra et CaRMetal par exemple.

La géométrie dynamique a étendu son champ d’exercice : les logiciels sont devenus des grapheurs, ils se sont essayés à la 3D, à l’écriture formelle, puis au calcul formel ...
On arrive à la notion de logiciels « multicarte » - on quitte alors la GD - dont l’un des plus aboutis est probablement le logiciel de la TI NSpire, entièrment décliné dans sa version tablette.

1.1.b. La question du transfert lors d’un changement de support

Le passage de l’ordinateur à la tablette renvoie à ce questionnement sur les valeurs de la GD que l’on désire transmettre. L’anticipation des créations - et même des constructions - semble être la première chose à conserver.

La question de sa faisabilité se pose tout de suite, ainsi que celle des conditions de cette éventuelle faisabilité. Si on regarde la version tablette actuelle de GeoGebra (mars 2014), on voit que les auteurs ont complètement renoncé à la simple anticipation de création des objets, pourtant présente dés 1988 lors des premières versions de Cabri-géométre puis ensuite de Cinderella. Et si on vidéo-projette sa tablette, les élèves ne voient pas où l’on déplace le doigt pour créer des objets. C’est objectivement assez désolant, on en est revenu à ... quelque chose qui n’a jamais existé en géométrie dynamique.
On peut juste espérer - pour la géométrie dynamique, mais aussi pour les élèves des utilisateurs de cette application - que cette politique de sortie rapide d’un outil utilisable soit repensée, si possible en profondeur.

Pourquoi ce choix ? Quel enjeu dans l’anticipation des créations d’objets ? A priori il n’y a pas vraiment de difficulté, la gestion des tablettes permet la création anticipée d’un segment, d’une droite, d’un cercle même : on utilise les fonctionnalités « TouchStart » pour le premier point, « TouchMove » pour l’anticipation de la construction de l’objet, et « TouchEnd » pour finaliser l’objet : ce lâcher de tablette correspondant au second clic de souris (techniquement ce serait un « OnMouseUp »).

Sauf que des objets essentiels de création - angle, triangle, polygone, bissectrice, arc de cercle, ou même cercle par trois points - nécessitent de cliquer sur plus de deux points. Et là, la gestion de l’interface de base des tablettes ne le permet pas. Il faut construire un environnement qui prenne un « TouchEnd » comme une saisie intermédiaire et attend un prochain « TouchStart » comme suite de la saisie d’un objet plus complexe.

Proposer l’anticipation de tous les objets de création oblige à proposer celle des objets à trois points initiaux, et , sur tablette, cela induit de repenser l’interface de saisie pour la création des objets. La raison fondamentale en fait est que la souris est un pointeur continu, au sens où le système sait toujours où est la souris, même relâchée par l’utilisateur, alors que quand le doigt est levé, la système ne peux pas savoir où l’utilisateur va le poser à nouveau : l’interface doit être conçue pour lui imposer de le poser quelque part pour que cela signifie, pour l’utilisateur comme pour le système que la construction de l’objet se poursuit.

Une fois ceci fait, a priori, c’est utilisable même pour les objets traditionnellement dit « de construction » : médiatrice, parallèle perpendiculaire, symétriques etc ... Ainsi travailler à cette interface, c’est travailler au respect des premières valeurs d’anticipation de la géométrie dynamique.

1.1.c. Les choix structurels de DGPad - l’outil infixé

« Le courage c’est de commencer » disait Jankélévitch. Il faut déjà celui-là : commencer quelque chose de nouveau. Mais il faut aussi celui d’innover : d’oser une interface radicalement nouvelle, parce que plus adaptée au nouveau support.

Alors que dans tous les logiciels de géométrie dynamique, créer ou construire un objet nous place dans le schème d’action standard de l’outil préfixé : on choisit un outil puis ensuite ses prémisses, dans DGPad, on choisit un premier objet, et alors des outils pour poursuivre la construction est proposé : l’outil est infixé dans la procédure de construction.

Pour construire une droite passant passant par deux points, le schème d’action est donc désormais : point - choix de l’outil droite - point (qui peut être construit à la volée)

Pour construire une parallèle à une droite passant par un point, le schème d’action est : droite - choix de l’outil parallèle - point (qui peut être construit à la volée)

Cela signifie que les outils sont proposés selon le contexte. En pratique, comme tout est ouvert et peux se faire à la volée, il y a essentiellement deux types de palette d’outils proposés, la palette des outils préfixés par un point, et la palette des outils préfixés par une droite ou un segment.

Par ailleurs ces palettes peuvent être contextualisées, dans plusieurs sens différents. : selon le contexte, et selon le mode : ainsi en mode 3D, les outils de droite, ou même de cercle par 3 points créent des outils 3D.

On notera que ce choix optimise aussi le nombre de « clics » (de TouchEnd en fait). L’auteur de DGPad a fait en sorte qu’il ne soit pas plus long de créer ou construire un objet sur tablette que sur ordinateur.

Les palettes d’outils sont détaillées au prochain onglet.

1.1.d. DGPad et les autres valeurs de la géométrie dynamique

L’auteur de DGPad - Eric Hakenholz (auteur de CaRMetal) a été élevé dans la culture de Cabri-géomètre. Il fut même un des cofondateurs - et le rédacteur en chef - de la revue papier abraCAdaBRI de 1993 à 1996.

C’était donc un challenge pour lui que les macros soient dans la toute première version de DGPad, tout comme elles l’étaient dans Cabri 1.0.

Pour ce qui est de l’engagement direct, le savoir faire développé sur CaRMetal se transpose relativement facilement dans d’autres logiciels. C’est le cas, par exemple, de la gestion des ambiguïtés, qui a d’emblée, la même qualité (non modale) que dans CaRMetal.

La seule chose que semble regretter actuellement l’auteur de DGPad, est que, pour le moment - et contrairement à CaRMetal - l’anticipation des constructions ne s’applique pas aux macro-constructions.

Haut de la barre d’interface pour aborder les outils

Partie 3D

Tableau de Bord

1.2. Les différents modes du tableau de bord

On distinguera trois types d’outils, ceux :

du tableau de bord, c’est l’interface générale, en bas de l’écran.
des palettes de construction, sur les points ou les droites.
de la palette des comportements.

Dans cet onglet on s’intéresse au premier point

1.2.a. Les premiers items du tableau de bord de DGPad

Par tableau de bord on entend les icones de commandes générales de l’interface qui sont souvent des modes de fonctionnement. Elles sont actuellement au nombre de sept pour l’environnement de travail sur les figures, auxquelles s’ajoutent quatre icones de gestion des fichiers - c’est donc un aspect important du logiciel - et deux mode d’environnement spécifiques.
À droite du tableau de bord, on retrouve les traditionnelles icones d’annulation et de rétablissement des constructions : ces deux items portent uniquement sur les constructions, pas sur les déplacements ou modifications cosmétiques.

Signalons tout de suite que l’annulation d’une macro-construction supprimer tous les objets intermédiaires construits : on utilisera préférentiellement ces items d’annulations pour les macros.

JPEG

Mode Pointeur
Si, comme dans CaRMetal ou Geogebra, le mode pointeur est privilégié pour la manipulation directe, il n’est pas modal pour le déplacement. Au contraire, en dehors du mode trait, on peut déplacer les objets dans les cinq autres modes : cacher/montrer, supprimer, macro, calculatrice, aspect des objets.
Par contre il faut être dans ce mode pour construire des objets mahématiques.

Mode traits
Le mode trait reprend la démarche kinesthésique, de Sketchometry par exemple, mais juste pour tracer des droites, segments et polygones. En particulier il n’y a pas d’analyse de l’orthogonalité : c’est un mode de création, pas un mode de constructions mathématique comme dans Sketchometry (qui a ses gestures pour lorthogonalité, les paralléles, le milieu ...)
Comme son nom l’indique bien c’est un mode « trait » il n’y a pas de reconnaissance de cercle.

On utilisera ce mode essentiellement dans les petites classes pour accompagner la découverte de l’application, par exemple en réactualisant sur tablette, le passage du perceptif à la modélisation mathématique des objets géométriques. Mais pour des constructions mathématiques il faut revenir au mode standard.

Exemple d’engagement direct fin en mode trait ou standard


L’engagement direct est parfois subtil à tel point qu’on ne le perçoit pas toujours. Par exemple pour le tracé d’une droite, dés Cabri II (1996), Jean Marie Laborde faisait remarquer que pendant l’anticipation de la création d’une droite, il était préférable de tracer un segment (ici qui se termine de manière évanescente ce qui n’était peut-être pas faisable à l’époque de Cabri) plutôt qu’une droite qui traverse tout l’écran : la réification est plus proche de la pensée de l’élève qui voit essentiellement entre les points et un peu autour plutôt que d’affirmer mathématiquement la dimension non bornée de la droite qu’il est entrain de tracer : on s’est aperçu, lors des analyse des premières version de Cabri, que c’était une surcharge visuelle pour certains élèves. Bien entendu le clic final de la souris (sur ordinateur) ou le lâcher du point (sur tablette) construit la droite entièrement à l’écran.

JPEG


Mode Cacher/Montrer
C’est le mode classique auquel on s’attend, avec une possibilité de ne pas voir ce qui a déjà été caché pour ne pas alourdir la figure si on ne veut juste que cacher de nouveaux objets. Le fonctionnement est donc plutôt celui de GeoGebra (mais sans modalité) plutôt que celui de la baguette magique de CaRMetal qui permet de continuer à construire des objets.

Il existe un mode super caché (pour que les élèves ne voient pas par exemple les objets intermédiaires, mais il n’est pas actuellement dans l’interface, la modification doit être faite dans le fichier texte de la figure. Par défaut, tous les objets intermédiaires des macros sont super cachés.

Super cacher un objet

Dans le style d’un objet, quand celui est caché il y a le paramètre h:1, pour le super cacher il faut mettre simplement un h:2.

Si l’objet n’est pas caché, il n’y a pas de paramétrè h (pour hidden) on rajoute un h:2 après la couleur par exemple, toujours présente.


Mode Supprimer
Classiquement, d’un point de vue informatique, les figures sont des arbres, supprimer un objet supprime bien entendu tous ses descendants.
A noter que supprimer une figure la place automatiquement dans le cache de l’application.
Ainsi supprimer une figure c’est aussi la sauvegarder en interne.

Mode Macro
Mode de réalisation d’une macro construction ou de l’application de macros-constructions, personnelles ou standards. Un onglet est dédié à ce mode. DGPad innove par rapport à la démarche historique des macros avec objets initiaux et finaux. On verra que c’est souvent pratique, mais qu’il faut parfois faire quelques rectificatifs.

Mode Calculatrice
Ou encore Mode Expressions. ON y traite des expressions algébriques, des tracés dec ourbes,mais aussi de la dérivation, des curseurs et programmation. Une barre d’onglet lui est dédiée tant ce mode est vaste puisque l’on peut y mettre tout le JavaScript que l’on veut ... ce qui peut faire parfois beaucoup.
On verra aussi, dans la partie 3D, la concision des écritures de points dans ce mode

Mode inspecteur d’objet
Le mode où l’on l’on peut choisir la couleur, les style des objets, mais aussi le nombres de segments des lieux ou les coniques, le pas des curseurs etc etc ...
Un onglet lui est dédié

1.2.b. Les items de gestion de fichiers

Quatre items sont disponibles

Figure du cache
Une vingtaine de figures sont en général disponibles dans cet item, que l’on peut cadenasser individuellement pour les conserver. Utilisable aussi bien avec l’application tablette que dans le mode webApp - sur ordinateur ou sur tablette - le comportement de cet item dépend alors du navigateur : Chrome et Firefox ne se comportent pas de la même façon. Le vidage du cache est aléatoire. Il conserve bien, dans tous les cas, les figures cadenassées.

PNG

Exports divers
DGPad a été conçu au départ avec 4 exports initiaux : les trois premiers pour être mis dans des pages HTML selon différentes contraintes commentées quand on les sélectionne. Dans ces trois premiers modes d’exportation, la figure est embarquée dans le code : si on a une figure lourde, cela alourdi d’autant le fichier. Pour des figures scolaires usuelles c’est négligeable. Le quatrième mode est une exportation en texte seul : c’ est le fichier (.txt) de la figure.

PNG

C’est un mode important car il permet de copier coller le texte de la figure dans un éditer de texte de base y compris sur tablette), pour faire différents traitements, comme des modifications à la main dans le fichier dans des utilisations plus expertes. On pense ici à la collecte de macros ou à un traitement un peu systématique des différents aspects conditionnels - un onglet de la seconde partie de l’article est consacré à cet aspect.

Charger (du) ou déposer dans le nuage
Ces modes sont importants dans le cadre de l’utilisation de l’application tablette. Dans le cas d’une utilisation sur ordinateur on peut s’en passer.

Plusieurs remarques :
• si on rapatrie la partie DGPad de son nuage personnel (DropBox, GoogleDrive, Evernote etc) sur sa tablette, on peut faire une lecture directe du fichier depuis l’application.
• avoir un serveur distant permet de donner l’adresse d’une figure à quelqu’un la syntaxe est : hppt ://dgpad.net/index.php?url= suivi de l’adresse de votre fichier - qui doit être dans un dossier public - dans votre nuage. Par exemple l’adresse des patrons de cube plus haut est :

http://www.dgpad.net/index.php?url=https://dl.dropboxusercontent.com/u/8044436/DGPad/3D/PatronsCubeSimplifie.txt

On peut l’envoyer comme cela par mail pour qu’il soit lu directement dans un navigateur.

La question du dossier public dans le nuage

Si votre fichier n’est pas dans un dossier Public, en fait, l’adresse de lecture de fichier est orientée vers un lecteur interne du nuage, et pas directement sur le fichier lui-même, ce qui est une protection normale car vos fichiers ne sont pas publiques.
Dans ce cas, DGPad ne peut interpréter cette action, car il ne tombe pas directement sur un fichier .txt.

Par exemple, DropBox ne produit plus de dossier public par défaut sur les nouveaux compte depuis juin 2012. Cela vientdrait de que trop d’utilisateurs n’avaient pas perçu que ce dossier était totalement public, ie accessible aux robots du web.
Mais, si vous avez un compte DropBox créé depuis cette date, il suffit de se connecter sur cette adresse (non active ici) : https://dropbox.com/enable_public_f...;: elle crée un dossier public pour votre compte. Et ce qui est décrit ci-dessus fonctionne bien.

Le cas de votre site personnel

Bien entendu, une adresse url d’une figure DGPad sur votre site personnel fonctionne par défaut. C’est donc une façon de distribuer naturellement des figures.

Pour mettre une figure distante dans un site - comme ici un site SPIP mais dans n’importe environnement web - il suffit de l’installer dans une iframe comme cela :

<iframe src="http://www.dgpad.net/index.php?url=https://dl.dropboxusercontent.com/u/8044436/DGPad/3D/PatronsCubeSimplifie.txt" style="width:720px;height:600px;border-style:solid;border-width:1px;box-shadow: 6px 6px 3px #888888;"></iframe>

Cas des onglets de SPIP
On ne peux pas mettre une figure avec le tableau de bord dans un onglet du couteau suisse (si quelqu’un peux expliquer pourquoi merci d’écrire à l’IREM ou de le mettre en commentaire). Par contre on peut y mettre une figure sans le tableau de bord. il faut alors ajouter ... un hide_ctrlpanel=true au nom du fichier (Plus précisément ajouter signifie mettre un ET (&) qui se code & en HTML, d’où le code final : &hide_ctrlpanel=true après le nom du fichier). Voici ce que cela donne :

<iframe src="http://www.dgpad.net/index.php?url=https://dl.dropboxusercontent.com/u/8044436/DGPad/Script_IterCarreCurseur.txt&amp;hide_ctrlpanel=true" style="width: 720px; height: 500px; border-style: solid; border-width: 1px; box-shadow: 6px 6px 3px #888888;"></iframe>
Mais en général un simple {{&}} suffit, il n'est pas codé.

Ce qui donne, dans cet onglet :


1.2.c. Les deux derniers modes du tableau de bord

Nommage automatique
Cet item place une liste de 2 fois 26 lettres en haut de l’écran : on définit une première lettre pour commencer. Les lettres sont utilisées par ordre alphabétique ce qui permet un nommage automatique des points ou des autres objets. Voici un exemple : le premier point se nomme automatiquement A, le second B le suivant sera C sauf si on en sélectionne un autre.

JPEG

On arrête le nommage automatique en cliquant à nouveau sur l’icone.

Axes
Ajoute les axes standards du logiciel.
On déplace la figure par un contrôle-clic sur ordinateur avec un ou deux doigts sur tablettes (les deux doigts non translatés font un zoom).

Haut de la barre d’interface

Partie 3D

Palettes de constructions

1.3. Les palettes de construction

Comme indiqué dans l’onglet d’introduction, pour obtenir l’anticipation des constructions tout en optimisant le nombre de « TouchEnd » (retrait du doigt de la tablette), les items de construction sont infixés entre un premier objet (une première prémisse de l’algorithme de construction) et un deuxième objet. Il en résulte nécessairement une toute autre interface de géométrie dynamique que ce que l’on connait, et surtout des schèmes d’action à reconstruire (du moins pour ceux qui ont pratiqué longuement une autre interface).

La première différence est que les actions s’offrent à nous ; cela peut être troublant les premières fois car, quand on sélectionne un objet, on sait ce que l’on veut faire avec. Mais en terme d’opérationnalité sélectionner l’item de construction avant ou pendant la construction n’offre pas de différence : l’interface est même plus proche ici des manipulations que l’on va faire.

Bien entendu la palette se construction s’adapte au contexte : selon que l’on sélectionne un point un segment, une droite ou un cercle, la palette des outils disponibles est différente et s’actualise.

1.3.a. Principe général de la manipulation - les nouveaux schèmes d’action de DGPad

Étape 1  : Un premier objet est sélectionné. On lâche l’objet - que ce soit à la souris ou au doigt, on parlera d’un premier « ToucheEnd ».

Étape 2  : On sélectionne l’outil (TouchStart), et en maintenant l’outil sélectionné, on va vers le deuxième prémisse de l’objet (ou on le crée à la volée). En interne c’est un « TouchMove », c’est là qu’intervient l’anticipation des constructions.
On sélectionne ce second objet (il devient surligné), et on confirme sa sélection en le lâchant. C’est un deuxième « TouchEnd ».

Étape 3 : L’objet est alors construit s’il ’est définit par deux objets. Sinon l’icone de l’objet réapparaît et on la sélectionne à nouveau pour poursuivre la construction.

Voici ce que donnent ces trois étapes pour la perpendiculaire à une droite passant par un point créé à la volée :

PNG


Et de manière encore plus détaillée, en visualisant les étapes intermédiaires, voici ce que cela donne avec un cercle passant par 3 points : cas de trois prémisses où la troisième étape se poursuit jusqu’à la sélection d’un troisième objet par un troisième « lâcher » de l’écran.

PNG

En pratique c’est bien plus rapide et naturel à faire que lire l’illustration précédente ;-)

On remarquera que par rapport aux logiciels de géométrie dynamiques classiques, il y a deux « TouchEnd » pour les objets qui se construisent en deux clics à la souris, et également trois « lâcher d’écran » quand les objets se font en trois clics de souris : le « nombre de clics » est le même avec cette nouvelle interface que dans les anciennes, seules les actions sont différentes : les outils ne sont plus préfixés. Mais on maintient, sur tablette, la construction anticipée de tous les objets, ce à quoi d’autres logiciels, dont certains majeurs, ont renoncé.

1.3.b. La palette des points

Quand on sélectionne un point il y a 14 actions possibles, 14 types d’objets que l’on peut construire. En effet comme les constructions peuvent être toutes anticipées, on peut aussi bien construire un segment, un cercle un polygone, une bissectrice ...

PNG

(ici la palette est accompagnée de celle des comportements qui sera abordée au prochain onglet)

Première ligne : segment, droite, demi droite, milieu, symétrie centrale d’un point, médiatrice, bissectrice
Seconde ligne : cercle par centre et point, cercle par centre et rayon (libre, algébrisable), compas (report de longueur), cercle par trois point, arc de cercle, polygone et angle.

Un quinzième outil

Quand un point est dépendant d’un autre, le premier sur un cercle, un segment ou une droite, un quinzième outil, lieu de point, apparaît sur la seconde ligne.

C’est alors itérable, et on peut faire des lieux de lieux.

1.3.c. Les palettes des segments ou droites.

Les palettes sont différentes, il y a deux outils de plus pour les segments (milieu et médiatrice)

PNG

Point sur objet - point dans objet
La première icone, le point est l’outil « point sur objet ». En pratique on n’oubliera pas que la position du point est celle au lâcher de l’outil : y penser sur le segment, sinon il va être confondu avec une extrémité..

De même, pour un polygone ce « point sur objet » peut devenir un point « dans l’objet »,si au lâcher de l’outil (le TouchEnd« ) le doigt ou la souris est à l’intérieur de l’objet, sinon c’est alors un point »dans le contour". Cette option est très pratique en 3D pour avoir des points sur les faces de polyèdres. Les points sont alors bien entendu des points 3D dont on peut utiliser les coordonnées.

Pour cet item, sur tablette, il y aussi le geste de la caresse qui permet, en passant le doigt sur une intersection ou dans un polygone (sans pointer, d’où l’expression de caresse) de créer le point à l’intersection ou dans le polygone.

1.3.d. Exemple d’engagement direct fin

Voici un exemple de construction du cercle circonscrit à trois points dont le troisième point est l’intersection (non pré-construite) de l’intersection de deux segments.

On remarquera, à la seconde étape, que le surlignage des deux segments signale à l’utilisateur (dont le doigt ne permet pas de voir - sauf en mode vidéo projection, et en vidéo projection - s’il est bien sur l’intersection) qu’il a bien sélectionné l’intersection des deux segments qui va être créée en même temps.

PNG

La version tablette de GeoGebra fait la même chose, c’est-à-dire saisit l’intersection pour le 3° point, mais c’est plus aléatoire car il n’y a pas de retour de ce que l’on fait et on peut sélectionner correctement l’intersection, ou pas.

Haut de la barre d’interface

Partie 3D

Palettes de comportements

1.4. La palette de comportements

Cette palette, elle aussi, s’adapte au contexte de la figure. Dans sa version complète, elle propose ces outils :

PNG

On voit donc qu’il y a à la fois des raccourcis pour éviter de retourner au tableau de bord, mais aussi des comportements particuliers. En particulier quand on utilise DGPad en webApp sur ordinateur, ce qui peut être plus courant en classe que d’utiliser une tablette, on peut oublier parfois l’intérêt de cette palette sur tablette.

Placer le nom : en sélectionnant cet item on fait tourner le nom d’un point au tour du point, diamétralement opposé au doigt.

Inspecteur d’objet et Expressions : recours rapide à ces modes, car souvent utilisés.

Déplacer un objet : permet de prendre un objet. Utilisable dans des cas ordinaires, mais réalisé pour des cas plus complexes en particulier d’ambiguïtés (points l’un sur l’autre, polygone à l’intérieur d’un autre etc)

Point Flottant : sert essentiellement maintenant pour la 3D. Cela permet qu’un point (et tous ses dépendants ne soient pas affectés par la rotation du trièdre : une figure 2D flotte ainsi à côté de la 3D, typiquement pour mettre une représentation graphique à côté d’une figure 3D.

L’option est disponible en 2D pour des utilisations « power user ». Il est possible qu’elle ne soit plus utile en 2D.

Aimantation : reprend l’outil de CaRMetal. Un point peut être aimanté par des points, droites segments, cercle etc ... Une différence avec CaRMetal : même un point sur objet (et surtout dans l’objet en 3D) peut être aimanté, ce qui n’est pas le cas avec CaRMetal.

L’aimantation permet de passer par un point qui ne serait pas abordable à la souris (les tiers ou racines carrées de pixels ou plus complexe) : pour réaliser une simulation, on peut ainsi faire passer un point sur objet par une solution particulière ...

Remarque : ce qui précède est le niveau 1 de l’application. Un niveau 2, en formation, peut être de proposer aux enseignants (ou aux futurs enseignants) une réflexion sur le fait que cette méthode fonctionne : imaginons que l’on veuille aimanter un point M au tiers d’un segment. On construit, avec le logiciel, le point au tiers, et par aimantation, M est alors reconnu comme identique à ce point, alors qu’en fait tout est discret en réalité : c’est la précision finie du logiciel, dans la construction de M et dans l’aimantation, qui permet de confirmer que les points sont confondus. Cela pose - éventuellement - la question du contrat (les plus sévères diraient de l’illusion) - mathématique - de la modélisation.

Exemple de réalisation : dans la figure suivante, figure d’investigation sur Thalès dans l’espace - entre autre - il faut que les élèves ouvrent la face pour la placer dans le plan de la face ABCD et ensuite déplacent M pour que, dans cette configuration , les points A, M, et I soient alignés, ce qui est validé par une différence des distances qui s’annulle (ie le triangle est aplati).

Mais pour réaliser l’annulation exacte de AI-AM-MI il faut que M soit exactement à la bonne position. Cela n’est pas possible à la souris (et avec le trièdre manipulable en plus). Donc M est légèrement aimanté (ici de 2 pixels) par la solution. Sans cela l’investigation ne serait pas possible ou serait moins accompagnée, plus complexe. C’est d’ailleurs un débat : faut-il accompagner ainsi des figures d’investigation ?


Mise en œuvre de l’aimantation

L’outil aimantation étant sélectionné pour un point, on choisit les différents objets qui l’aimantent et avec quelle force il est aimanté : on peut mettre des attirances différentes par des objets différents.

PNG

Supprimer une aimantation

L’icone d’aimantation est un switch aimanter/désaimanter. Dans l’illustration suivante M était aimanté par un segment et un cercle, en sélectionnant le point puis l’icone d’aimantation, et à nouveau le cercle d’aimantation, on peut mettre le curseur sur « Sans » et le point n’est plus aimanté par le cercle.

Haut de la barre d’interface

Partie 3D

Inspecteur d’objet

1.5. L’inspecteur d’objets

En réalité, ce titre est prématuré, cette palette de réglage sur les objets n’est pas encore vraiment un inspecteur d’objet comme peuvent l’être les palettes du même nom dans CaRMetal ou GeoGebra par exemple. Disons que c’est une aspiration d’utilisateur à ce qu’elle évolue peu à peu dans cette direction. Un inspecteur d’objet contiendrait par exemple une possibilité d’annuler et d’éditer l’aimantation d’un point.

1.5.a. Le mode projection

A son ouverture ’« à vide », c’est-à-dire depuis le tableau de bord, sans passer par la palette des comportements, on commence par voir un mode présentation fort pratique en vidéo projection ou le public peut voir où l’on pose son doigt sur la tablette.

JPEG

C’est un mode essentiel pour une utilisation collective. Le doigt est un peu gros mais au moins largement visible. Il est transparent donc cela permet au manipulateur de la tablette de voir lui-même au vidéo projecteur « sous son doigt ». Voici ce que cela donne :

JPEG

Ci dessus on construit la médiatrice d’une diagonale d’un quadrilatère :
• illustration de gauche : le doigt de l’utilisateur a déjà sélectionné le premier point et va vers le second. La médiatrice est construite en anticipation.
• illustration du centre : chacun, et l’utilisateur, voit que le point est surligné, donc présélectionné. Le doigt est encore en contact avec la tablette.
• illustration de droite : le doigt n’est plus en contact : le point a été sélectionné (par un TouchEnd). La médiatrice est tracée, le disque est entrain de se résorber (rétroaction dynamique).

1.5.b. Quelques éléments de l’inspecteur d’objet

PNG

Sur cette première copie d’écran on voit que l’épaisseur, pour les polygones s’applique au contour, et que la mesure correspond à l’aire (comme pour les autres logiciels). Pour le cercle la mesure correspond au rayon. Bien entendu les noms des objets sont des variables utilisables dans le module expression.

Des aires géométriques
Dans CaRMetal par exemple, l’aire qui s’affiche est une aire géométrique (utilisation en collège) mais la variable associée est algébrique (en respectant l’orientation, pour une utilisation plus sophistiquée). Dans DGPad, il semble que la variable algébrique associée à l’aire soit toujours positive. C’est vrai que la subtilité des variables de CaRMetal a toujours posé quelques problèmes, en formation par exemple, mais cela pouvait être utile quand on la maitrisait bien. Ici, dans le cas d’une utilisation mobile, l’auteur a préféré ne pas reproduire cette subtile distinction entre l’affichage écran et la valeur interne de la variable.

Appliquer à tous
On note que ce panneau de contrôle de l’aspect des objets contient quelques éléments d’un inspecteur d’objet comme le traitement multiple, ci-dessous illustré sur les points qui ont tous étés rendus opaques par le traitement sur un seul.

PNG

On notera aussi l’incrément possible sur les modification des points : ici les points sont sur la grille demi entière du logiciel ce qui permet d’avoir des aires décimales bien particulières.

Cet incrément permet de transformer un curseur en booléen, il suffit que l’amplitude du curseur soit 1 et l’incrément aussi : la variable associée devient un booléen, ce qui est bien utile pour des figures sophistiquées avec choix de manipulation ou d’affichage.

1.5.c. Mesure et densité

L’item mesure s’adapte au contexte de l’objet : on a vu qu’il peut signifier une longueur ou une aire. Dans le cas d’un lieu, l’item change de nom car il devient une densité (de segments).

Sur l’illustration suivante, on a réalisé une pseudosphère et le cercle circonscrit - en bleu - d’un triangle - rouge, - manipulable par ses points A, B, C et leurs altitudes uA (non visible), uB, uC, à partir de l’intersection des médiatrices -vertes. I, J, K sont les milieux des côtés.
Dans cette modélisation 3D, tout objet de cette géométrie est un lieu. Pour rendre la figure plus fluide, on peut régler la densité de ces lieux selon les besoins : les segments, petits, ont une densité à 20 objets, le cercle est à 100 objets et les droites sont réglées sur 200 objets.

PNG

On imagine assez bien que, pour produire une telle figure, un environnement de micromonde robuste est indispensable. La figure a été faite pour tester la robustesse à la fois du micromonde et de l’implémentation 3D dont on reparlera dans la troisième partie de cet article. Pour passer ce test de robustesse, DGPad a dû travailler quelques optimisations internes qui profitent ensuite à tous les utilisateurs (qui en général ne feront jamais de figures aussi lourdes).

Haut de la barre d’interface

Partie 3D

Macros

1.6. Les macro-constructions et les micromondes de DGPad

Cet onglet s’intéresse à trois choses :
a) l’utilisation des macros de la bibliothèque du logiciel. Nous en ferons un rapide tour d’horizon.
b) la réalisation de macros construction et leur organisation
c) une réflexion sur la qualité des micromondes que propose DGPad.

Sensibilisé à cette question des macro-constructions et des micromondes, nous avons déjà beaucoup écrit sur ce sujet (dans les deux onglets macro et micromonde dans cet article de MathémaTICE (mai 2013) lors de la sortie de DGPad. On y présente des exemples sur les cercles, et les coniques, construites alors comme lieu. Si les analyses sur la qualité d’un microonde restent d’actualité, DGPad a sensiblement progressé depuis cette époque en ce domaine. Les conclusions ne sont donc plus les mêmes. Une conséquence de cette évolution est que les figures sur les barycentres, les coniques et la géométrie hyperbolique proposées en téléchargement à la fin de cet article sont désormais obsolètes. Seules celles sur les cercles sont toujours intéressantes.

1.6.1. Les macros de bibliothèque de DGPad

L’item des macros est le cinquième à partir de la gauche dans le tableau de bord (clé à molette et marteau). Contrairement à la situation du premier article de MathemaTICE, les macros de bibliothèque et les macros personnelles sont (ou peuvent être) des macros hiérarchiques. Celles dites « de bibliothèque », les macros internes, se présentent actuellement ainsi :

PNG

Sur la première ligne on voit que toutes les macros sont dans des dossiers, sur la seconde ligne, que le lieu où l’on est rappelé dans la partie inférieure du bloc, pour remonter la hiérarchie, et que ces dossiers peuvent contenir des macros ou des dossiers (ou les deux).

Nous ne ferons pas le tour de toutes les macros. Voyons simplement leur utilisation : soit à construire rapidement un triangle rectangle.

PNG

• Étape 1 : une fois sélectionnée la macro, elle invite à la création ou sélection d’un objet, et annonce le type d’objet et le nombres d’objet à sélectionner (ou créer).
• Étape 2 : la macro propose la sélection d’un deuxième objet. (ici un second point).
• Étape 3 : quand la dernière prémisse à la construction est donnée, la macro achève la construction, et l’item macro est encore actif et attend à nouveau la sélection d’un premier objet.

1.6.b. Exemple de possibilité d’engagement direct dans une macro écrite en JavaScript

Que ce soit dans Cabri, Geogebra ou CaRMetal, le retour des tests n’est pas vraiment satisfaisant : il est dynamique mais non nominatif dans Cabri et CaRMetal, il est nominatif mais statique (et modal) dans GeoGebra. Avec DGPad, on a enfin un retour de test comme on l’a toujours souhaité ... et même comme on l’a jamais rêvé.

Dans la figure suivante, M est aimanté par les deux droites et leur intersection pour tester la macro alignement qui renvoie le commentaire avec les noms des points. Mais en plus, si, avec la palette grise dse comportements, vous sélectionnez l’inspecteur d’objet, vous pouvez modifier les noms de E et F en P et Q, alors la macro, déjà appliquée, sait s’adapter, en temps réel, au changement de nom des points.


1.6.c. Réaliser une macro -construction personnelle

On pourrait penser que la procédure standard : « désignation des objets initiaux, puis des objets finaux, et écriture du nom de la macro » est une séquence immuable, incontournable, puisqu’on la pratique, pour les plus anciens d’entre nous, depuis Cabri 1.0, depuis 1988 !

Pourtant nourri lui aussi de cette culture, Eric Hakenholz a voulu proposer un pas de côté dans la réalisation des macros : les objets finaux potentiels sont évalués au fur et à mesure que l’on propose des objets initiaux. La procédure modifie sensiblement nos schèmes d’action, du moins pour des situations bien spécifiques.

On le voit sur un cas élémentaire, tout en plaçant directement la macro dans un dossier (ici un dossier Plan). On se propose de faire une macro Orthocentre à partir de trois points d’un triangle. Voici les différentes étapes :

PNG

• Étape 1 : La figure étant faite, on ouvre le module Macro-construction. La sélection d’un premier objet (ici un point) fait entrer dans le mode Création d’une macro personnelle..
• Étape 2 : La sélection d’un deuxième objet complète les objets initiaux (point vert) et affiche les premiers objets finaux possibles (bouton enregistrent rouge).
• Étape 3 : Le troisième sommet du triangle sélectionné remplit les objets finaux de toute la figure. On notera que les objets finaux potentiels sont affichés en noir dans la figure.
• Étape 4 : Les objets initiaux sélectionnés, on poursuit en sélectionnant désormais les objets finaux (ici le point H). Ce n’est pas parce que tous les autres objets disparaissent qu’on ne peux plus les sélectionner : on le fait directement sur la figure. Il peut y avoir plusieurs objets finaux.
• Étape 5 : Ensuite on donne un nom à la macro. Ici on voit que l’on a donné un nom de dossier et de macro.
• Étape 6 : La macro Orthocentre est dans le dossier Plan.

1.6.d. Les points sur objet des macros personnelles et autres comportements

Comme c’est le logiciel qui décrit quels sont les objets qui dépendent des objets initiaux, un point M sur objet d’un cercle ou d’un segment [AB] est un objet dépendant, donc il ne pourra être sélectionné comme objet initial dés que le cercle, ou les deux points A et B seront sélectionnés comme initiaux.

A priori, en général ce n’est pas un problème et c’est même souvent une simplification. Pourtant, il peut y avoir des situations où on a envie d’avoir ce point M quand même en objet initiaux. Dans ce cas il faut le montrer avant de sélectionner ses objets parents, il restera dans les objets initiaux. C’est en particulier le cas si ce point sur objet doit servir dans la répétition de la macro : s’il n’est pas dans les initiaux, la macro va crée un nouveau point sur objet au hasard et en conséquence, une partie de la figure dépendant d’un autre point sur objet, elle ne réagirait pas au point M initial.

On peut alors être amené à réorganiser « à la main » la macro si on veut que ce point soit le dernier à montrer par exemple. Cela sera abordé dans le dernier onglet sur le format de fichier de DGPad.

Exécution des macros constructions

On peut se demander si une macro construction est appelée par le programme qui l’utilise ou si elle est appliquée (exécutée). Si on écrit des programmes avec DGPad on peut appeler une macro dans un programme (cela a été présenté dans cet article). Mais lors de l’appel, tout comme quand on l’applique à la main dans une figure, la macro est exécutée, c’est-à-dire que les points intermédiaires sont définitivement créés (ils sont super caché, on ne les voit pas même si on veut faire apparaître les objets cachés). Avec le fichier produit - quand on l’enregistre, la figure fonctionne même si on supprimer la macro du corps de son texte, elle a déjà été appliquée, elle ne sera pas rappelée pour une nouvelle exécution.

1.6.e. La qualité du micromonde produit

On a déjà dégagé (dans cet article, onglet micromonde) deux approche pour la qualité d’un micromonde : ses qualités externes, et ses qualités internes.

Les qualités externes

Il s’agit de l’organisation des macros en groupes et l’édition et la gestions de ces groupes, la qualité de leur accessibilité etc ...

Typiquement Cabri-géomètre, sous l’impulsion de son chef de projet, Jean Marie Laborde, avait poussé très loin cette qualité. Elle n’a jamais été atteinte par CaRMetal et ne l’a été - pour cette méta-gestion des macros proprement dite - par GeoGebra que dans ses dernières version. Sous GeoGebra ce qui pêche c’est la qualité des macros elles-mêmes : pour faire une macro « centre d’homothétie de deux cercles » on ne peux pas montrer les deux cercles, il faut montrer 4 points, au moins jusque dans la récente version 4.2.

Pour le moment, même si DGPad a une gestion interne de macros hiérarchique ce qui est un gros progrès par rapport à sa première version, il n’y a pas de gestion des blocs de macros : on ne peux pas les charger par exemple indépendamment d’une figure qui les contient. Et a fortiori, il n’y a pas de gestionnaire d’environnement. ll faut modifier les fichiers à la main (ie dans un éditeur de texte, faire des copier coller de macros) pour mettre dans un fichier les macros construction dont on a besoin. Cela dit, si on a les outils nécessaire, c’est faisable même sur tablette, ce n’est qu’une gestion de fichier.

Clairement ce point là n’a pas encore été travaillé au niveau de l’interface de DGPad, cela ne semble pas non plus une priorité pour son auteur, qui a tant de choses à faire avant.

Une première qualité interne : l’accès à la manipulation directe pendant la constrruction.

Par qualité interne, on entend le comportement intrinséque du logiciel vis à vis de ses macros. Là aussi, dès le départ, Cabri-géométrie avait ouvert la voie en mettant la barre très haute, comme dans beaucoup d’autres domaines.

Dans le même article déjà cité, on a déjà parlé de l’importance de l’accessibilité à la figure en manipulation directe pendant la création d’une macro-construction si on a besoin que différents points qui existent dans des situations complémentaires (disjointent) de la figure puissent apparaitrent en objet finaux. Toujours dans ce même article, on a illustré cela d’un exemple simple qui fonctionnait déjà avec Cabri II en 1996.

Une deuxième qualité interne : l’accessibilité aux objets constituant des objets initiaux

Une autre qualité interne encore plus fine, et conceptuellement importante, pour emboiter des macros en optimisant les objets, est l’accessibilité aux éléments constituants des objets initiaux ... et en particulier des objets initiaux des macros que l’on va utiliser.

C’est en particulier parce que cette condition n’était pas toujours remplie lors de la sortie du logiciel en mars 2013 que les figures hyperboliques de l’article de MathémaTICE sont obsolètes : pour prendre une perpendiculaire à une droite, pour éviter des redondances catastrophiques, il fallait montrer non pas la droite et un point mais les objets constituants de la droite et le point. C’est transparent à l’utilisateur ... tant qu’on ne lui donne pas les macros.

Désormais DGPad gère correctement ce point. Par exemple, si on travaille sur une conique définie par 5 points, on peut utiliser ses constituants tout en donnant comme objet initial la conique seule, les objets constituants utilisés sont retrouvés et figurent ainsi dans le corps de la macro.

PNG

Pour cette macro de polaire d’un point par rapport à une conique, on voit que la conique est un objet initial de la macro, et on commence par dire que l’on utilise A et P3 le premier et et dernier constituant (numéroté 0 et 4) de cette conique. Bien entendu tout ceci est transparent à l’utilisateur qui en général ne s’en aperçoit pas si on ne le précise pas comme ici,

C’est une condition essentielle à l’efficacité des macros constructions et à la construction de micromondes pertinents et robustes.

Haut de la barre d’interface

Partie 3D

Les fichiers

1.7. Les fichiers de DGPad

Les fichiers de DGPad sont des fichiers en JavaScript, mais en pratique, sauf si on souhaite vraiment programmer, on ne s’en aperçoit pas. Pour des raisons techniques un peu évidentes, l’auteur a choisi l’extension .txt, donc ce sont essentiellement des fichiers texte, et on les traitera de cette façon, dans un simple éditeur de texte.

En particulier sur tablette, on peut aussi facilement que sur ordinateur, éditer, modifier des figures de DGPad directement dans un éditeur de texte.

On l’aura compris, DGPad ne contient pas son propre éditeur de texte, pour alléger son chargement en ligne. Mais il a son éditeur d’expression dont on parlera abondamment dans la deuxième partie de cet article.

Il est tout à fait clair que l’on doit faire des figures d’un logiciel de géométrie dynamique sans aller fouiller dans la structure interne de ses fichiers. A priori il est fait pour cela. Et aller au delà n’intéresse pas nécessairement beaucoup de monde.

Mais d’un autre côté comme on dispose d’un format de fichier complètement ouvert, cela peut intéresser certains utilisateurs de rentrer dedans en particulier pour pouvoir modifier à la marge - parfois pour des raisons cosmétiques - le fichier à la main.

La suite de cet onglet n’intéressera donc que les personnes qui veulent aller un peu plus loin dans les entrailles d’un logiciel de géométrie dynamique, du moins sur la couche externe de sa communication avec ses propres fichiers.

1.7.a. La structure des fichiers de DGPad.

Ouvrons la figure de l’orthocentre, avant de faire la macro.

// Coordinates System :
SetCoords(503,341.5,40);
// Geometry :
A=Point("A",-2.25,4.2125);
B=Point("B",-5.35,0.8625);
C=Point("C",-0.6,-0.9125);
S1=Segment("S1",A,B);
S2=Segment("S2",B,C);
S3=Segment("S3",C,A);
Perp1=Perpendicular("Perp1",S3,B);
Perp2=Perpendicular("Perp2",S1,C);
H=OrderedIntersection("H",Perp2,Perp1,0);
// Styles :
STL(A,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(B,"c:#0000b2;o:0.91;s:6;sn:true;f:17");
STL(C,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
STL(S3,"c:#006633;s:1;f:24");
STL(Perp1,"c:#780013;s:1;f:30;p:0");
STL(Perp2,"c:#780013;s:1;f:30;p:0");
STL(H,"c:#b40000;s:6;sn:true;f:17");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

On voit trois parties :
• une première ligne qui situe l’origine du repère et l’échelle utlisée
• une partie « Géométrie » qui est le coeur de la figure, son programme de construction.
• une partir « Style » qui précise, pour chaque objet à l’écran les éléments de sa représentation.

On notera une dernière ligne SetCoordStyle qui se régénère elle même si on l’oublie. Par contre la première ligne SetCoords est essentielle.

Pour les curieux (et ceux qui veulent aller plus loin) voici le sens des différents styles.

Extrait du code de lecture des styles

var STL = function(_n, _s) {
        var o = me.f(_n);
        _s = _s.split(";");
        for (var i = 0, len = _s.length; i < len; i++) {
            var e = _s[i].split(":");
            e[1] = me.p(e[1]);
            switch (e[0]) {
                case "c":// Color
                    o.setColor(e[1]);
                    break;
                case "h":// Hidden
                    o.setHidden(e[1]);
                    break;
                case "o":// Opacity
                    o.setOpacity(parseFloat(e[1]));
                    break;
                case "s":// Size
                    o.setSize(parseFloat(e[1]));
                    break;
                case "sn":// Show name
                    o.setShowName(e[1]);
                    break;
                case "f":// Font size
                    o.setFontSize(parseInt(e[1]));
                    break;
                case "l":// Layer
                    o.setLayer(parseInt(e[1]));
                    break;
                case "p":// Précision numérique
                    o.setPrecision(e[1]);
                    break;
                case "sp":// Forme des points
                    o.setShape(parseInt(e[1]));
                    break;
                case "i":// Incrément
                    o.setIncrement(parseFloat(e[1]));
                    break;
                case "sb":// Sur le contour d'un polygone
                    o.setOnBoundary(e[1]);
                    break;
                case "dh":// Pointillés
                    o.setDash(e[1]);
                    break;
                case "np":// Position du nom des objets
                    o.setNamePosition(e[1]);
                    break;
                case "tk":// Trace de l'objet
                    if (e[1]) {
                        setTimeout(function() {
                            me.Z.trackManager.add(o, true);
                        }, 1);
                    }
                    break;
                case "fl": // Objet flottant
                    if (e[1]) {
                        o.setFloat(true);
                        o.free = function() {
                            return false;
                        }
                    }
                    break;
                case "cPT": // Point d'un curseur d'expression
                    var stls = me.$U.base64_decode(e[1]);
                    STL(o.getcPTName(), stls);
                    break;
                case "cL": // Longueur d'un curseur
                    o.setCursorLength(parseInt(e[1]));
                    break;
                case "mg": // Magnétisme des objets
                    var t = eval("[" + e[1] + "]");
                    for (var k = 0; k < t.length; k++) {
                        t[k][0] = me.C.find(t[k][0]);
                    }
                    ;
                    o.setMagnets(t);
                    break;
            }
        }
    };


Ajoutons maintenant la macro orthocentre, le code du fichier devient :

// Macros :
$macros={};
$macros["PlanOrthocentre"]={
        name:"Plan/Orthocentre",
        parameters:["point","point","point"],
        exec:
        function (A,B,C){
S1=Segment("S1",A,B);
S3=Segment("S3",C,A);
Perp1=Perpendicular("Perp1",S3,B);
Perp2=Perpendicular("Perp2",S1,C);
H=OrderedIntersection("H",Perp2,Perp1,0);
STL(H,"c:#b40000;s:6;sn:true;f:17");
return [H];
}};
// Coordinates System :
SetCoords(503,341.5,40);
// Geometry :
A=Point("A",-2.25,4.2125);
B=Point("B",-5.35,0.8625);
C=Point("C",-0.6,-0.9125);
S1=Segment("S1",A,B);
S2=Segment("S2",B,C);
S3=Segment("S3",C,A);
Perp1=Perpendicular("Perp1",S3,B);
Perp2=Perpendicular("Perp2",S1,C);
H=OrderedIntersection("H",Perp2,Perp1,0);
// Styles :
STL(A,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(B,"c:#0000b2;o:0.91;s:6;sn:true;f:17");
STL(C,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(S1,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
STL(S3,"c:#006633;s:1;f:24");
STL(Perp1,"c:#780013;s:1;f:30;p:0");
STL(Perp2,"c:#780013;s:1;f:30;p:0");
STL(H,"c:#b40000;s:6;sn:true;f:17");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

On voit que la macro est avant la première ligne de coordonnées, et qu’elle reprend les mêmes noms que la figure qui a défini cette macro.

1.7.b. Applications successives de macros - objets super cachés

L’application de la macro va, en général modifier les noms avec comme suffixe un indice entier. Appliquons notre macro orthocentre, dans la même figure, à un autre triangle PQR. Cela donne le code suivant :

// Macros :
$macros={};
$macros["PlanOrthocentre"]={
        name:"Plan/Orthocentre",
        parameters:["point","point","point"],
        exec:
        function (A,B,C){
S1=Segment("S1",A,B);
S3=Segment("S3",C,A);
Perp1=Perpendicular("Perp1",S3,B);
Perp2=Perpendicular("Perp2",S1,C);
H=OrderedIntersection("H",Perp2,Perp1,0);
STL(H,"c:#b40000;s:6;sn:true;f:17");
return [H];
}};
// Coordinates System :
SetCoords(503,341.5,40);
// Geometry :
B=Point("B",-5.35,0.8625);
A=Point("A",-2.25,4.2125);
R=Point("R",3.45,2.2875);
Q=Point("Q",0.95,0.3125);
P=Point("P",0.625,3.9375);
C=Point("C",-0.6,-0.9125);
S3=Segment("S3",C,A);
S2=Segment("S2",B,C);
S1=Segment("S1",A,B);
S11=Segment("S11",P,Q);
S31=Segment("S31",R,P);
Perp2=Perpendicular("Perp2",S1,C);
Perp1=Perpendicular("Perp1",S3,B);
Perp11=Perpendicular("Perp11",S31,Q);
Perp21=Perpendicular("Perp21",S11,R);
H1=OrderedIntersection("H1",Perp21,Perp11,0);
H=OrderedIntersection("H",Perp2,Perp1,0);
// Styles :
STL(B,"c:#0000b2;o:0.91;s:6;sn:true;f:17");
STL(A,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(R,"c:#0000b2;s:6;sn:true;f:30");
STL(Q,"c:#0000b2;s:6;sn:true;f:30");
STL(P,"c:#0000b2;s:6;sn:true;f:30");
STL(C,"c:#0000b2;o:1;s:6;sn:true;f:17");
STL(S3,"c:#006633;s:1;f:24");
STL(S2,"c:#006633;s:1;f:24");
STL(S1,"c:#006633;s:1;f:24");
STL(S11,"c:#006633;h:2;s:1;f:24");
STL(S31,"c:#006633;h:2;s:1;f:24");
STL(Perp2,"c:#780013;s:1;f:30;p:0");
STL(Perp1,"c:#780013;s:1;f:30;p:0");
STL(Perp11,"c:#780013;h:2;s:1;f:30;p:0");
STL(Perp21,"c:#780013;h:2;s:1;f:30;p:0");
STL(H1,"c:#b40000;s:6;sn:true;f:17");
STL(H,"c:#b40000;s:6;sn:true;f:17");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

La macro a été appliquée, c’est-à-dire qu’elle a construit les segments S11 et S31 mais aussi les perpendiculaires Perp11 et Perp21, et H1. Ainsi tous les objet crées ont leurs noms sont suffixés par un indice entier : une nouvelle création donnerait des segments S12 et S32 ainsi qu’un orthocentre H2.

Les objets super cachés

Mais surtout on notera que les objets créés sont « super cachés », ils ont un « h:2 » dans leur style de Hidden, au lieu d’un « h:1 » pour simplement « caché » : cela signifie que ces objets ne sont pas visibles par l’utilisateur, même s’il essaie de les faire apparaître par cacher/montrer.

C’est très souvent le première utilisation que l’on fait des modifications des fichiers : super cacher certaines constructions pour que les élèves ne les voient pas, pour avoir une figure « plus nette », en ne laissant simplement cachés que quelques points essentiels pour l’analyse d’une figure par exemple.

L’expérience de CaRMetal a montré qu’il est assez facile d’implémenter une interface pour « dé-super cacher » des objets sans que les élèves ne s’en aperçoive mais cela n’a pas encore été implémenté dans DGPad : même super cacher un objet n’est pas encore implémenté.

1.7.c. Gestion manuelle des macros et personnalisation.

Comme déjà dit dans l’onglet sur les macro, pour le moment il n’y a pas dans l’interface une gestion des dossiers de macros en dehors de leur création.

Le reste de cette gestion se passe dans les fichiers texte : on peut regrouper les macros qui vont nous servir sur quelques séances dans un même dossier et mettre ce dossier dans une figure, éventuellement vide mais qui contien au moins la ligne SetCoords.

Les macros sont simplement séparées par une ligne. On peut aussi choisir de faire un fichier qui contient plusieurs dossiers différents.

Exemple d’un dossier de macros sur les coniques


Bon cela ne sert plus vraiment, mais pourquoi pas ...

// Macros :
$macros={};
$macros["Cnk1P2TC"]={
        name:"Coniques/Constructions/Cnk 1P 2TC",
        parameters:["point","line","point","line","point"],
        exec:
        function (C,L2,AB1,L1,BA1){
L3=Line("L3",C,BA1);
L31=Line("L31",C,BA1);
L4=Line("L4",C,AB1);
P=OrderedIntersection("P",L2,L1,0);
Perp1=Perpendicular("Perp1",L3,P);
N=OrderedIntersection("N",Perp1,L3,0);
M=OrderedIntersection("M",L4,Perp1,0);
L6=Line("L6",BA1,M);
L5=Line("L5",AB1,N);
C1=OrderedIntersection("C1",L6,L5,0);
L21=Line("L21",AB1,C1);
L41=Line("L41",C,C1);
P2=OrderedIntersection("P2",L21,L1,0);
Perp11=Perpendicular("Perp11",L31,P2);
N1=OrderedIntersection("N1",Perp11,L31,0);
M1=OrderedIntersection("M1",L41,Perp11,0);
L51=Line("L51",BA1,M1);
L61=Line("L61",AB1,N1);
C11=OrderedIntersection("C11",L61,L51,0);
Quad=Quadric("Quad",AB1,C,C1,C11,BA1);
STL(Quad,"c:#007c7c;s:3.5;f:30;p:500");
return [Quad];
}};
$macros["Cnk3P1TC"]={
        name:"Coniques/Constructions/Cnk 3P 1TC",
        parameters:["point","point","point","line","point"],
        exec:
        function (A,C,B1,L1,BA1){
L2=Line("L2",A,B1);
L3=Line("L3",C,BA1);
L4=Line("L4",C,B1);
P=OrderedIntersection("P",L2,L1,0);
Perp1=Perpendicular("Perp1",L3,P);
N=OrderedIntersection("N",Perp1,L3,0);
M=OrderedIntersection("M",L4,Perp1,0);
L5=Line("L5",BA1,M);
L6=Line("L6",A,N);
C1=OrderedIntersection("C1",L6,L5,0);
Quad=Quadric("Quad",A,C,B1,C1,BA1);
STL(Quad,"c:#007c7c;s:3.5;f:30;p:500");
return [Quad];
}};
$macros["Cnk2TC1T"]={
        name:"Coniques/Constructions/Cnk 2TC 1T",
        parameters:["line","point","line","point","line"],
        exec:
        function (L2,P,L1,Q,L3){
A=OrderedIntersection("A",L2,L1,0);
C=OrderedIntersection("C",L3,L2,0);
B=OrderedIntersection("B",L3,L1,0);
P6=OrderedIntersection("P6",L2,L1,0);
L4=Line("L4",P,B);
L5=Line("L5",C,Q);
P4=OrderedIntersection("P4",L5,L4,0);
L6=Line("L6",A,P4);
R=OrderedIntersection("R",L6,L3,0);
L311=Line("L311",R,Q);
L31=Line("L31",R,Q);
L41=Line("L41",R,P);
Perp1=Perpendicular("Perp1",L31,P6);
M=OrderedIntersection("M",L41,Perp1,0);
N=OrderedIntersection("N",Perp1,L31,0);
L61=Line("L61",Q,M);
L51=Line("L51",P,N);
C1=OrderedIntersection("C1",L61,L51,0);
L21=Line("L21",P,C1);
L411=Line("L411",R,C1);
P21=OrderedIntersection("P21",L21,L1,0);
Perp11=Perpendicular("Perp11",L311,P21);
N1=OrderedIntersection("N1",Perp11,L311,0);
M1=OrderedIntersection("M1",L411,Perp11,0);
L511=Line("L511",Q,M1);
L611=Line("L611",P,N1);
C11=OrderedIntersection("C11",L611,L511,0);
Quad=Quadric("Quad",P,R,C1,C11,Q);
STL(Quad,"c:#007c7c;s:3.5;f:30;p:500");
return [Quad];
}};
$macros["Cnk5tangentes"]={
        name:"Coniques/Constructions/Cnk 5 tangentes",
        parameters:["line","line","line","line","line"],
        exec:
        function (d1,d2,d3,d4,d5){
P11=OrderedIntersection("P11",d5,d1,0);
P12=OrderedIntersection("P12",d2,d1,0);
P13=OrderedIntersection("P13",d3,d2,0);
P14=OrderedIntersection("P14",d4,d3,0);
P15=OrderedIntersection("P15",d5,d4,0);
L1=Line("L1",P11,P14);
L2=Line("L2",P15,P13);
L4=Line("L4",P12,P15);
L6=Line("L6",P11,P13);
L8=Line("L8",P12,P14);
P16=OrderedIntersection("P16",L2,L1,0);
P17=OrderedIntersection("P17",L4,L1,0);
P18=OrderedIntersection("P18",L4,L6,0);
P19=OrderedIntersection("P19",L8,L6,0);
P20=OrderedIntersection("P20",L8,L2,0);
L3=Line("L3",P12,P16);
L5=Line("L5",P13,P17);
L7=Line("L7",P14,P18);
L9=Line("L9",P15,P19);
L10=Line("L10",P11,P20);
T1=OrderedIntersection("T1",L3,d4,0);
T2=OrderedIntersection("T2",L5,d5,0);
T3=OrderedIntersection("T3",L7,d1,0);
T4=OrderedIntersection("T4",L9,d2,0);
T5=OrderedIntersection("T5",L10,d3,0);
Quad=Quadric("Quad",T1,T2,T3,T4,T5);
STL(Quad,"c:#ed00ff;s:2.5;f:30;p:500");
return [Quad];
}};
$macros["Cnk4P1T"]={
        name:"Coniques/Constructions/Cnk 4P 1T",
        parameters:["point","point","point","point","line"],
        exec:
        function (A,B,C,D,L1){
L5=Line("L5",B,D);
L4=Line("L4",C,A);
L2=Line("L2",B,A);
L3=Line("L3",C,D);
Q=OrderedIntersection("Q",L3,L1,0);
N=OrderedIntersection("N",L5,L1,0);
P=OrderedIntersection("P",L2,L1,0);
M=OrderedIntersection("M",L4,L1,0);
I=Point("I","[(x(P)*x(Q)-x(M)*x(N))/(x(P)+x(Q)-x(M)-x(N)),(y(P)*y(Q)-y(M)*y(N))/(y(P)+y(Q)-y(M)-y(N))]","0");
M1=MidPoint("M1",M,N);
C1=Circle("C1",M1,M);
M2=MidPoint("M2",M1,I);
C2=Circle("C2",M2,I);
P1=OrderedIntersection("P1",C2,C1,1);
C3=Circle("C3",I,P1);
P2=OrderedIntersection("P2",L1,C3,0);
P3=OrderedIntersection("P3",L1,C3,1);
Quad=Quadric("Quad",A,B,C,D,P2);
Quad1=Quadric("Quad1",D,A,P3,B,C);
STL(P2,"c:#0000b2;s:6;f:30");
STL(P3,"c:#0000b2;s:6;f:30");
STL(Quad,"c:#00adff;s:1;f:30;p:500");
STL(Quad1,"c:#00adff;s:1;f:30;p:500");
return [P2,P3,Quad,Quad1];
}};
$macros["Cnk1T2P1TC"]={
        name:"Coniques/Constructions/Cnk 1T 2P 1TC",
        parameters:["line","point","point","line","point"],
        exec:
        function (L1,A,B,L5,C){
L31=Line("L31",A,C);
L2=Line("L2",B,A);
L3=Line("L3",C,B);
L4=Line("L4",C,A);
L41=Line("L41",A,B);
L22=Line("L22",A,B);
P=OrderedIntersection("P",L4,L1,0);
M=OrderedIntersection("M",L5,L1,0);
Q=OrderedIntersection("Q",L3,L1,0);
N=OrderedIntersection("N",L2,L1,0);
P4=OrderedIntersection("P4",L22,L5,0);
I=Point("I","[(x(P)*x(Q)-x(M)*x(N))/(x(P)+x(Q)-x(M)-x(N)),(y(P)*y(Q)-y(M)*y(N))/(y(P)+y(Q)-y(M)-y(N))]","0");
M1=MidPoint("M1",M,N);
M2=MidPoint("M2",M1,I);
C1=Circle("C1",M1,M);
C2=Circle("C2",M2,I);
P1=OrderedIntersection("P1",C2,C1,1);
C3=Circle("C3",I,P1);
sol1=OrderedIntersection("sol1",L1,C3,0);
sol2=OrderedIntersection("sol2",L1,C3,1);
L42=Line("L42",sol2,B);
L21=Line("L21",sol1,B);
L32=Line("L32",sol2,C);
Perp11=Perpendicular("Perp11",L32,P4);
P3=OrderedIntersection("P3",L21,L5,0);
M4=OrderedIntersection("M4",L42,Perp11,0);
N2=OrderedIntersection("N2",Perp11,L32,0);
Perp1=Perpendicular("Perp1",L31,P3);
N1=OrderedIntersection("N1",Perp1,L31,0);
M3=OrderedIntersection("M3",L41,Perp1,0);
L52=Line("L52",C,M4);
L61=Line("L61",A,N2);
L6=Line("L6",sol1,N1);
L51=Line("L51",C,M3);
C12=OrderedIntersection("C12",L61,L52,0);
C11=OrderedIntersection("C11",L6,L51,0);
Quad1=Quadric("Quad1",A,sol2,B,C12,C);
Quad=Quadric("Quad",sol1,A,B,C11,C);
STL(sol1,"c:#0000b2;s:6;sn:true;f:30");
STL(sol2,"c:#0000b2;s:6;sn:true;f:30");
STL(Quad1,"c:#16db08;s:3.5;f:30;p:500");
STL(Quad,"c:#0007ff;s:3.5;f:30;p:500");
return [sol1,sol2,Quad1,Quad];
}};
$macros["PointsPoncelet"]={
        name:"Coniques/Constructions/Points Poncelet",
        parameters:["line","point","point","point","point"],
        exec:
        function (L1,M,N,P,Q){
I=Point("I","[(x(P)*x(Q)-x(M)*x(N))/(x(P)+x(Q)-x(M)-x(N)),(y(P)*y(Q)-y(M)*y(N))/(y(P)+y(Q)-y(M)-y(N))]","0");
M1=MidPoint("M1",M,N);
C1=Circle("C1",M1,M);
M2=MidPoint("M2",M1,I);
C2=Circle("C2",M2,I);
P1=OrderedIntersection("P1",C2,C1,1);
C3=Circle("C3",I,P1);
P2=OrderedIntersection("P2",L1,C3,0);
P3=OrderedIntersection("P3",L1,C3,1);
STL(P2,"c:#0000b2;s:6;f:18");
STL(P3,"c:#0000b2;s:6;f:18");
return [P2,P3];
}};
$macros["DivHarmoABCD"]={
        name:"Coniques/Outils/DivHarmo ABC D",
        parameters:["point","point","point"],
        exec:
        function (A,B,C){
d1=Line("d1",B,A);
C1=Circle("C1",A,B);
Perp1=Perpendicular("Perp1",d1,A);
Perp2=Perpendicular("Perp2",d1,B);
P4=OrderedIntersection("P4",Perp1,C1,1);
L1=Line("L1",P4,C);
P5=OrderedIntersection("P5",Perp2,L1,0);
Symc1=Symmetry("Symc1",B,P5);
L2=Line("L2",P4,Symc1);
D=OrderedIntersection("D",L2,d1,0);
STL(C,"c:#0000b2;s:6;sn:true;f:18");
STL(D,"c:#b40000;s:6;sn:true;f:18;sp:2");
return [C,D];
}};
$macros["Polaire1pt"]={
        name:"Coniques/Outils/Polaire 1 pt",
        parameters:["quadric","point"],
        exec:
        function (Quad,P4){
A=DefinitionPoint("A",Quad,0);
P3=DefinitionPoint("P3",Quad,4);
L1=Line("L1",P4,A);
L2=Line("L2",P4,P3);
P5=OrderedIntersection("P5",L1,Quad,1,A);
P6=OrderedIntersection("P6",L2,Quad,1,P3);
d1=Line("d1",P6,P3);
C1=Circle("C1",P3,P6);
d11=Line("d11",P5,A);
C11=Circle("C11",A,P5);
Perp1=Perpendicular("Perp1",d1,P3);
Perp2=Perpendicular("Perp2",d1,P6);
Perp11=Perpendicular("Perp11",d11,A);
Perp21=Perpendicular("Perp21",d11,P5);
P41=OrderedIntersection("P41",Perp1,C1,1);
P42=OrderedIntersection("P42",Perp11,C11,1);
L11=Line("L11",P41,P4);
L12=Line("L12",P42,P4);
P51=OrderedIntersection("P51",Perp2,L11,0);
P52=OrderedIntersection("P52",Perp21,L12,0);
Symc1=Symmetry("Symc1",P6,P51);
Symc11=Symmetry("Symc11",P5,P52);
L21=Line("L21",P41,Symc1);
L22=Line("L22",P42,Symc11);
D=OrderedIntersection("D",L21,d1,0);
D1=OrderedIntersection("D1",L22,d11,0);
L3=Line("L3",D,D1);
STL(L3,"c:#780013;s:1;f:18;p:0");
return [L3];
}};
$macros["Tgt1ptCnk"]={
        name:"Coniques/Outils/Tgt 1 pt (de) Cnk",
        parameters:["quadric","point"],
        exec:
        function (Quad,M){
B=DefinitionPoint("B",Quad,1);
P2=DefinitionPoint("P2",Quad,3);
P6=Point("P6","Quad.center()","0");
L1=Line("L1",P6,M);
Par1=Parallel("Par1",L1,B);
Par2=Parallel("Par2",L1,P2);
P4=OrderedIntersection("P4",Par1,Quad,1,B);
P5=OrderedIntersection("P5",Par2,Quad,0,P2);
M1=MidPoint("M1",P5,P2);
M2=MidPoint("M2",B,P4);
L2=Line("L2",M2,M1);
Par3=Parallel("Par3",L2,M);
STL(Par3,"c:#780013;s:1;f:18;p:0");
return [Par3];
}};
$macros["TgtesptExtCnk"]={
        name:"Coniques/Outils/Tgtes pt Ext Cnk",
        parameters:["quadric","point"],
        exec:
        function (Quad,M){
P2=DefinitionPoint("P2",Quad,1);
P3=DefinitionPoint("P3",Quad,2);
L3=Line("L3",P2,P3);
L2=Line("L2",M,P3);
L1=Line("L1",M,P2);
P6=OrderedIntersection("P6",L2,Quad,0,P3);
P7=OrderedIntersection("P7",L1,Quad,1,P2);
L4=Line("L4",P6,P7);
L6=Line("L6",P3,P7);
L5=Line("L5",P6,P2);
I=OrderedIntersection("I",L4,L3,0);
J=OrderedIntersection("J",L6,L5,0);
L7=Line("L7",J,I);
R=OrderedIntersection("R",L7,Quad,0);
S=OrderedIntersection("S",L7,Quad,1);
L8=Line("L8",M,S);
L9=Line("L9",M,R);
STL(R,"c:#0000b2;s:6;sn:true;f:30");
STL(S,"c:#0000b2;s:6;sn:true;f:30");
STL(L8,"c:#780013;s:1;f:30;p:0");
STL(L9,"c:#780013;s:1;f:30;p:0");
return [R,S,L8,L9];
}};
$macros["CnkpardirF1pt"]={
        name:"Coniques/Euclidiennes/Cnk par dir F 1pt",
        parameters:["line","point","point"],
        exec:
        function (dir,F,A){
Perp1=Perpendicular("Perp1",dir,F);
P3=OrderedIntersection("P3",Perp1,dir,0);
C1=Circle("C1",P3,F);
P5=OrderedIntersection("P5",dir,C1,1);
P4=OrderedIntersection("P4",dir,C1,0);
Symc1=Symmetry("Symc1",P4,P3);
L21=Line("L21",P4,F);
L22=Line("L22",P5,F);
L12=Line("L12",P5,A);
L11=Line("L11",P4,A);
Perp22=Perpendicular("Perp22",L22,F);
Perp21=Perpendicular("Perp21",L21,F);
L1=Line("L1",Symc1,A);
M1=MidPoint("M1",P4,Symc1);
L2=Line("L2",Symc1,F);
Syma12=Reflection("Syma12",Perp22,A);
L13=Line("L13",M1,A);
L23=Line("L23",M1,F);
Syma11=Reflection("Syma11",Perp21,A);
Perp2=Perpendicular("Perp2",L2,F);
L31=Line("L31",F,Syma11);
Syma1=Reflection("Syma1",Perp2,A);
L32=Line("L32",F,Syma12);
Perp23=Perpendicular("Perp23",L23,F);
Syma13=Reflection("Syma13",Perp23,A);
B2=OrderedIntersection("B2",L32,L12,0);
B1=OrderedIntersection("B1",L31,L11,0);
L3=Line("L3",F,Syma1);
L33=Line("L33",F,Syma13);
B=OrderedIntersection("B",L3,L1,0);
B3=OrderedIntersection("B3",L33,L13,0);
Quad=Quadric("Quad",B,B3,B1,A,B2);
STL(Quad,"c:#00adff;s:2;f:30;p:1000");
return [Quad];
}};
$macros["CnkBifocDFe"]={
        name:"Coniques/Euclidiennes/Cnk Bifoc. DFe",
        parameters:["line","point","expression"],
        exec:
        function (dir,F,e){
Perp1=Perpendicular("Perp1",dir,F);
C1=Circle1("C1",F,"e");
K=OrderedIntersection("K",Perp1,dir,0);
Perp2=Perpendicular("Perp2",Perp1,F);
P5=OrderedIntersection("P5",Perp2,C1,0);
U3=OrderedIntersection("U3",Perp2,C1,1);
C2=Circle1("C2",K,"1");
U1=Point("U1","K+U3-F","0");
P3=OrderedIntersection("P3",dir,C2,0);
P4=Point("P4","F+(e/(1+e))*(U1-F)","0");
P7=Point("P7","F-(e/(1-e))*(U1-F)","0");
Perp3=Perpendicular("Perp3",dir,U1);
S1=Segment("S1",P3,P5);
Symc2=Symmetry("Symc2",P3,K);
M2=MidPoint("M2",P4,P7);
S=OrderedIntersection("S",S1,Perp1,0);
L2=Line("L2",Symc2,F);
C3=Circle("C3",M2,P4);
L1=Line("L1",Symc2,S);
Perp4=Perpendicular("Perp4",L2,F);
bf1=OrderedIntersection("bf1",Perp3,C3,0);
P9=OrderedIntersection("P9",Perp3,C3,1);
Syma3=Reflection("Syma3",Perp4,S);
bf2=Reflection("bf2",Perp1,bf1);
bf4=Reflection("bf4",Perp1,P9);
L3=Line("L3",F,Syma3);
bf3=OrderedIntersection("bf3",L3,L1,0);
Quad=Quadric("Quad",bf1,S,bf2,bf3,bf4);
STL(Quad,"c:#00adff;s:2;f:30;p:500");
return [Quad];
}};
$macros["CnkGeneDFe"]={
        name:"Coniques/Euclidiennes/CnkGene DFe",
        parameters:["line","point","expression"],
        exec:
        function (dir,F,e){
C1=Circle1("C1",F,"e");
Perp1=Perpendicular("Perp1",dir,F);
Perp2=Perpendicular("Perp2",Perp1,F);
K=OrderedIntersection("K",Perp1,dir,0);
C4=Circle("C4",K,F);
P5=OrderedIntersection("P5",Perp2,C1,0);
C2=Circle1("C2",K,"1");
U3=OrderedIntersection("U3",Perp2,C1,1);
prbS=MidPoint("prbS",F,K);
P3=OrderedIntersection("P3",dir,C2,0);
P6=OrderedIntersection("P6",dir,C4,0);
U1=Point("U1","K+U3-F","0");
P8=OrderedIntersection("P8",dir,C4,1);
Perp3=Perpendicular("Perp3",dir,U1);
S1=Segment("S1",P3,P5);
Symc2=Symmetry("Symc2",P3,K);
Perp6=Perpendicular("Perp6",dir,P6);
P7=Point("P7","F-(e/(1-e))*(U1-F)","0");
P4=Point("P4","F+(e/(1+e))*(U1-F)","0");
M3=MidPoint("M3",P6,K);
M4=MidPoint("M4",K,P8);
L5=PerpendicularBisector("L5",F,P6);
L4=PerpendicularBisector("L4",F,M3);
M2=MidPoint("M2",P4,P7);
prb2=OrderedIntersection("prb2",L5,Perp6,0);
S=OrderedIntersection("S",S1,Perp1,0);
Perp5=Perpendicular("Perp5",dir,M3);
Symc3=Symmetry("Symc3",P8,M4);
L2=Line("L2",Symc2,F);
L6=PerpendicularBisector("L6",F,Symc3);
Perp7=Perpendicular("Perp7",dir,Symc3);
C3=Circle("C3",M2,P4);
L1=Line("L1",Symc2,S);
Perp4=Perpendicular("Perp4",L2,F);
prb1=OrderedIntersection("prb1",L4,Perp5,0);
CnkS=Point("CnkS","prbS*(e==1)+S*(e!=1)","0");
P9=OrderedIntersection("P9",Perp3,C3,1);
Syma3=Reflection("Syma3",Perp4,S);
prb3=Reflection("prb3",Perp1,prb1);
bf1=OrderedIntersection("bf1",Perp3,C3,0);
prb4=OrderedIntersection("prb4",L6,Perp7,0);
bf4=Reflection("bf4",Perp1,P9);
bf2=Reflection("bf2",Perp1,bf1);
Cnk1=Point("Cnk1","prb1*(e==1)+bf1*(e!=1)","0");
L3=Line("L3",F,Syma3);
Cnk2=Point("Cnk2","prb2*(e==1)+bf2*(e!=1)","0");
Cnk4=Point("Cnk4","prb4*(e==1)+bf4*(e!=1)","0");
bf3=OrderedIntersection("bf3",L3,L1,0);
Cnk3=Point("Cnk3","prb3*(e==1)+bf3*(e!=1)","0");
Quad2=Quadric("Quad2",Cnk1,CnkS,Cnk2,Cnk3,Cnk4);
STL(Quad2,"c:#ff00b5;s:2;f:30;p:1000");
return [Quad2];
}};
$macros["ParaboledirF"]={
        name:"Coniques/Euclidiennes/Parabole dir F",
        parameters:["line","point"],
        exec:
        function (dir,F){
Perp1=Perpendicular("Perp1",dir,F);
K=OrderedIntersection("K",Perp1,dir,0);
prbS=MidPoint("prbS",F,K);
C4=Circle("C4",K,F);
P8=OrderedIntersection("P8",dir,C4,1);
P6=OrderedIntersection("P6",dir,C4,0);
L5=PerpendicularBisector("L5",F,P6);
M4=MidPoint("M4",K,P8);
M3=MidPoint("M3",P6,K);
Perp6=Perpendicular("Perp6",dir,P6);
prb2=OrderedIntersection("prb2",L5,Perp6,0);
L4=PerpendicularBisector("L4",F,M3);
Perp5=Perpendicular("Perp5",dir,M3);
Symc3=Symmetry("Symc3",P8,M4);
Perp7=Perpendicular("Perp7",dir,Symc3);
L6=PerpendicularBisector("L6",F,Symc3);
prb1=OrderedIntersection("prb1",L4,Perp5,0);
prb3=Reflection("prb3",Perp1,prb1);
prb4=OrderedIntersection("prb4",L6,Perp7,0);
Quad1=Quadric("Quad1",prb2,prb1,prbS,prb3,prb4);
STL(Quad1,"c:#00adff;s:2;f:30;p:1000");
return [Quad1];
}};
$macros["TgteCom2Cnk"]={
        name:"Coniques/Tgtes Comm. 2 Cnk",
        parameters:["quadric","quadric"],
        exec:
        function (Quad,Quad1){
B=DefinitionPoint("B",Quad,1);
A=DefinitionPoint("A",Quad,0);
P1=DefinitionPoint("P1",Quad,2);
P2=DefinitionPoint("P2",Quad,3);
P3=DefinitionPoint("P3",Quad,4);
P4=DefinitionPoint("P4",Quad1,0);
P5=DefinitionPoint("P5",Quad1,1);
P7=DefinitionPoint("P7",Quad1,3);
P8=DefinitionPoint("P8",Quad1,4);
L1=Line("L1",A,P4);
L2=Line("L2",A,P8);
L13=Line("L13",B,P4);
L23=Line("L23",B,P8);
L14=Line("L14",P1,P4);
L24=Line("L24",P1,P8);
L15=Line("L15",P2,P4);
L25=Line("L25",P2,P8);
L16=Line("L16",P3,P4);
L26=Line("L26",P3,P8);
P51=OrderedIntersection("P51",L1,Quad1,1,P4);
P61=OrderedIntersection("P61",L2,Quad1,1,P8);
P53=OrderedIntersection("P53",L13,Quad1,1,P4);
P62=OrderedIntersection("P62",L23,Quad1,1,P8);
P54=OrderedIntersection("P54",L14,Quad1,1,P4);
P63=OrderedIntersection("P63",L24,Quad1,1,P8);
P55=OrderedIntersection("P55",L15,Quad1,1,P4);
P64=OrderedIntersection("P64",L25,Quad1,1,P8);
P56=OrderedIntersection("P56",L16,Quad1,1,P4);
P65=OrderedIntersection("P65",L26,Quad1,1,P8);
P66=Point("P66","Quad1.center()","0");
P67=Point("P67","Quad1.center()","0");
P68=Point("P68","Quad1.center()","0");
P69=Point("P69","Quad1.center()","0");
d1=Line("d1",P61,P8);
C1=Circle("C1",P8,P61);
d11=Line("d11",P51,P4);
C11=Circle("C11",P4,P51);
d12=Line("d12",P62,P8);
C12=Circle("C12",P8,P62);
d111=Line("d111",P53,P4);
C111=Circle("C111",P4,P53);
d13=Line("d13",P63,P8);
C13=Circle("C13",P8,P63);
d112=Line("d112",P54,P4);
C112=Circle("C112",P4,P54);
d14=Line("d14",P64,P8);
C14=Circle("C14",P8,P64);
d113=Line("d113",P55,P4);
C113=Circle("C113",P4,P55);
d15=Line("d15",P65,P8);
C15=Circle("C15",P8,P65);
d114=Line("d114",P56,P4);
C114=Circle("C114",P4,P56);
Perp1=Perpendicular("Perp1",d1,P8);
Perp2=Perpendicular("Perp2",d1,P61);
Perp11=Perpendicular("Perp11",d11,P4);
Perp21=Perpendicular("Perp21",d11,P51);
Perp12=Perpendicular("Perp12",d12,P8);
Perp22=Perpendicular("Perp22",d12,P62);
Perp111=Perpendicular("Perp111",d111,P4);
Perp211=Perpendicular("Perp211",d111,P53);
Perp13=Perpendicular("Perp13",d13,P8);
Perp23=Perpendicular("Perp23",d13,P63);
Perp112=Perpendicular("Perp112",d112,P4);
Perp212=Perpendicular("Perp212",d112,P54);
Perp14=Perpendicular("Perp14",d14,P8);
Perp24=Perpendicular("Perp24",d14,P64);
Perp113=Perpendicular("Perp113",d113,P4);
Perp213=Perpendicular("Perp213",d113,P55);
Perp15=Perpendicular("Perp15",d15,P8);
Perp25=Perpendicular("Perp25",d15,P65);
Perp114=Perpendicular("Perp114",d114,P4);
Perp214=Perpendicular("Perp214",d114,P56);
P41=OrderedIntersection("P41",Perp1,C1,1);
P42=OrderedIntersection("P42",Perp11,C11,1);
P411=OrderedIntersection("P411",Perp12,C12,1);
P421=OrderedIntersection("P421",Perp111,C111,1);
P412=OrderedIntersection("P412",Perp13,C13,1);
P422=OrderedIntersection("P422",Perp112,C112,1);
P413=OrderedIntersection("P413",Perp14,C14,1);
P423=OrderedIntersection("P423",Perp113,C113,1);
P414=OrderedIntersection("P414",Perp15,C15,1);
P424=OrderedIntersection("P424",Perp114,C114,1);
L11=Line("L11",P41,A);
L12=Line("L12",P42,A);
L111=Line("L111",P411,B);
L121=Line("L121",P421,B);
L112=Line("L112",P412,P1);
L122=Line("L122",P422,P1);
L113=Line("L113",P413,P2);
L123=Line("L123",P423,P2);
L114=Line("L114",P414,P3);
L124=Line("L124",P424,P3);
P511=OrderedIntersection("P511",Perp2,L11,0);
P52=OrderedIntersection("P52",Perp21,L12,0);
P512=OrderedIntersection("P512",Perp22,L111,0);
P521=OrderedIntersection("P521",Perp211,L121,0);
P513=OrderedIntersection("P513",Perp23,L112,0);
P522=OrderedIntersection("P522",Perp212,L122,0);
P514=OrderedIntersection("P514",Perp24,L113,0);
P523=OrderedIntersection("P523",Perp213,L123,0);
P515=OrderedIntersection("P515",Perp25,L114,0);
P524=OrderedIntersection("P524",Perp214,L124,0);
Symc1=Symmetry("Symc1",P61,P511);
Symc11=Symmetry("Symc11",P51,P52);
Symc12=Symmetry("Symc12",P62,P512);
Symc111=Symmetry("Symc111",P53,P521);
Symc13=Symmetry("Symc13",P63,P513);
Symc112=Symmetry("Symc112",P54,P522);
Symc14=Symmetry("Symc14",P64,P514);
Symc113=Symmetry("Symc113",P55,P523);
Symc15=Symmetry("Symc15",P65,P515);
Symc114=Symmetry("Symc114",P56,P524);
L21=Line("L21",P41,Symc1);
L22=Line("L22",P42,Symc11);
L211=Line("L211",P411,Symc12);
L221=Line("L221",P421,Symc111);
L212=Line("L212",P412,Symc13);
L222=Line("L222",P422,Symc112);
L213=Line("L213",P413,Symc14);
L223=Line("L223",P423,Symc113);
L214=Line("L214",P414,Symc15);
L224=Line("L224",P424,Symc114);
D=OrderedIntersection("D",L21,d1,0);
D1=OrderedIntersection("D1",L22,d11,0);
D2=OrderedIntersection("D2",L211,d12,0);
D11=OrderedIntersection("D11",L221,d111,0);
D3=OrderedIntersection("D3",L212,d13,0);
D12=OrderedIntersection("D12",L222,d112,0);
D4=OrderedIntersection("D4",L213,d14,0);
D13=OrderedIntersection("D13",L223,d113,0);
D5=OrderedIntersection("D5",L214,d15,0);
D14=OrderedIntersection("D14",L224,d114,0);
L3=Line("L3",D,D1);
L31=Line("L31",D2,D11);
L32=Line("L32",D3,D12);
L33=Line("L33",D4,D13);
L34=Line("L34",D5,D14);
P11=OrderedIntersection("P11",L3,L31,0);
P12=OrderedIntersection("P12",L34,L31,0);
P13=OrderedIntersection("P13",L33,L34,0);
P14=OrderedIntersection("P14",L32,L33,0);
P15=OrderedIntersection("P15",L3,L32,0);
L17=Line("L17",P11,P14);
L27=Line("L27",P15,P13);
L4=Line("L4",P12,P15);
L6=Line("L6",P11,P13);
L8=Line("L8",P12,P14);
P16=OrderedIntersection("P16",L27,L17,0);
P17=OrderedIntersection("P17",L4,L17,0);
P18=OrderedIntersection("P18",L4,L6,0);
P19=OrderedIntersection("P19",L8,L6,0);
P20=OrderedIntersection("P20",L8,L27,0);
L35=Line("L35",P12,P16);
L5=Line("L5",P13,P17);
L7=Line("L7",P14,P18);
L9=Line("L9",P15,P19);
L10=Line("L10",P11,P20);
T1=OrderedIntersection("T1",L35,L32,0);
T2=OrderedIntersection("T2",L5,L3,0);
T3=OrderedIntersection("T3",L7,L31,0);
T4=OrderedIntersection("T4",L9,L34,0);
T5=OrderedIntersection("T5",L10,L33,0);
Quad2=Quadric("Quad2",T1,T2,T3,T4,T5);
P9=OrderedIntersection("P9",Quad2,Quad1,0);
P10=OrderedIntersection("P10",Quad2,Quad1,1);
P21=OrderedIntersection("P21",Quad2,Quad1,3);
P22=OrderedIntersection("P22",Quad2,Quad1,2);
L18=Line("L18",P66,P22);
L19=Line("L19",P67,P21);
L110=Line("L110",P68,P10);
L115=Line("L115",P69,P9);
Par1=Parallel("Par1",L18,P5);
Par2=Parallel("Par2",L18,P7);
Par11=Parallel("Par11",L19,P5);
Par21=Parallel("Par21",L19,P7);
Par12=Parallel("Par12",L110,P5);
Par22=Parallel("Par22",L110,P7);
Par13=Parallel("Par13",L115,P5);
Par23=Parallel("Par23",L115,P7);
P43=OrderedIntersection("P43",Par1,Quad1,1,P5);
P57=OrderedIntersection("P57",Par2,Quad1,0,P7);
P44=OrderedIntersection("P44",Par11,Quad1,1,P5);
P58=OrderedIntersection("P58",Par21,Quad1,0,P7);
P45=OrderedIntersection("P45",Par12,Quad1,1,P5);
P59=OrderedIntersection("P59",Par22,Quad1,0,P7);
P46=OrderedIntersection("P46",Par13,Quad1,1,P5);
P510=OrderedIntersection("P510",Par23,Quad1,0,P7);
M1=MidPoint("M1",P57,P7);
M2=MidPoint("M2",P5,P43);
M11=MidPoint("M11",P58,P7);
M21=MidPoint("M21",P5,P44);
M12=MidPoint("M12",P59,P7);
M22=MidPoint("M22",P5,P45);
M13=MidPoint("M13",P510,P7);
M23=MidPoint("M23",P5,P46);
L28=Line("L28",M2,M1);
L29=Line("L29",M21,M11);
L210=Line("L210",M22,M12);
L215=Line("L215",M23,M13);
Par3=Parallel("Par3",L28,P22);
Par31=Parallel("Par31",L29,P21);
Par32=Parallel("Par32",L210,P10);
Par33=Parallel("Par33",L215,P9);
STL(Par3,"c:#780013;s:1;f:30;p:0");
STL(Par31,"c:#780013;s:1;f:30;p:0");
STL(Par32,"c:#780013;s:1;f:30;p:0");
STL(Par33,"c:#780013;s:1;f:30;p:0");
return [Par3,Par31,Par32,Par33];
}};
// Coordinates System :
SetCoords(471.2930683043573,321.9782862652776,41.72745443805635);
// Geometry :
P1=Point("P1",-0.2706388025927066,-0.21620570572103784);
P5=Point("P5",3.2481205000603035,4.279107938355723);
C=Point("C",-2.864379118674214,-2.389073463900116);
BA1=Point("BA1",2.749999999999986,-0.01249999999999422);
AB1=Point("AB1",-2.100000000000003,2.037500000000002);
E1=Expression("E1","Conique par 3points , une tangente et son contact ","","","0","-11.054905565570468","4.84041715425298");
L3=Line("L3",C,BA1);
L2=Line("L2",AB1,P1);
L4=Line("L4",C,AB1);
L1=Line("L1",BA1,P5);
L31=Line("L31",C,BA1);
P=OrderedIntersection("P",L2,L1,0);
Perp1=Perpendicular("Perp1",L3,P);
N=OrderedIntersection("N",Perp1,L3,0);
M=OrderedIntersection("M",L4,Perp1,0);
L6=Line("L6",BA1,M);
L5=Line("L5",AB1,N);
C1=OrderedIntersection("C1",L6,L5,0);
L21=Line("L21",AB1,C1);
L41=Line("L41",C,C1);
P2=OrderedIntersection("P2",L21,L1,0);
Perp11=Perpendicular("Perp11",L31,P2);
N1=OrderedIntersection("N1",Perp11,L31,0);
M1=OrderedIntersection("M1",L41,Perp11,0);
L51=Line("L51",BA1,M1);
L61=Line("L61",AB1,N1);
C11=OrderedIntersection("C11",L61,L51,0);
Quad=Quadric("Quad",AB1,C,C1,C11,BA1);
// Styles :
STL(P1,"c:#966400;s:6;f:30;sp:1");
STL(P5,"c:#966400;s:6;f:19;sp:1");
STL(C,"c:#0000b2;s:6;sn:true;f:19");
STL(BA1,"c:#ff00d3;s:6;sn:true;f:19");
STL(AB1,"c:#0000b2;s:6;sn:true;f:19");
STL(E1,"c:#135f10;s:7;f:17;p:-1;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjoxOQ==");
STL(L3,"c:#780013;s:1;f:30;p:0");
STL(L2,"c:#e827de;s:2.5;f:30;p:0");
STL(L4,"c:#780013;s:1;f:30;p:0");
STL(L1,"c:#ce00ff;s:2.5;f:30;p:0");
STL(L31,"c:#780013;h:2;s:1;f:30;p:0");
STL(P,"c:#0000b2;s:6;sn:true;f:30");
STL(Perp1,"c:#007c00;s:1;f:30;p:0");
STL(N,"c:#007c00;s:6;sn:true;f:30");
STL(M,"c:#007c00;s:6;sn:true;f:30");
STL(L6,"c:#780013;s:1;f:30;p:0");
STL(L5,"c:#780013;s:1;f:30;p:0");
STL(C1,"c:#0000b2;s:6;sn:true;f:30");
STL(L21,"c:#780013;h:2;s:1;f:30;p:0");
STL(L41,"c:#780013;h:2;s:1;f:30;p:0");
STL(P2,"c:#0000b2;h:2;s:6;f:30");
STL(Perp11,"c:#780013;h:2;s:1;f:30;p:0");
STL(N1,"c:#0000b2;h:2;s:6;f:30");
STL(M1,"c:#0000b2;h:2;s:6;f:30");
STL(L51,"c:#780013;h:2;s:1;f:30;p:0");
STL(L61,"c:#780013;h:2;s:1;f:30;p:0");
STL(C11,"c:#0000b2;h:2;s:6;f:30");
STL(Quad,"c:#007c7c;s:3.5;f:30;p:500");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

Ce qui, placé dans un fichier texte, donne ceci dans DGPad :

PNG


Personnaliser le nom d’un objet dans une macro

C’est la seconde utilisation intéressante de modification de nom de fichier, même si cela ne sert pas souvent : en pratique cela sert plus pour les expressions, nous verrons cela plus loin.

Considérons la macro suivante qui construit, géométriquement, l’intersection des médianes.

$macros={};
$macros["IsoBar_3pts"]={
        name:"IsoBar_3pts",
        parameters:["point","point","point"],
        exec:
        function (A,B,C){
I=MidPoint("I",A,B);
J=MidPoint("J",B,C);
S1=Segment("S1",I,C);
S2=Segment("S2",A,J);
G=OrderedIntersection("G",S2,S1,0);
STL(G,"c:#0000b2;s:6;sn:true;f:30");
return [G];
}};

Et modifions là en ceci (on n’a modifié que les noms internes et externe et la ligne qui donne le nom externe « G » que l’on a remplacé par « g »+A+B+C

$macros["IsoBarNomme3pts"]={
        name:"IsoBar 3pts nommés",
        parameters:["point","point","point"],
        exec:
        function (A,B,C){
I=MidPoint("I",A,B);
J=MidPoint("J",B,C);
S1=Segment("S1",I,C);
S2=Segment("S2",A,J);
G=OrderedIntersection("g"+A+B+C,S2,S1,0);
STL(G,"c:#0000b2;s:6;sn:true;f:30");
return [G];
}};

Appliquons alors cette macro à un quadrilatère. Comme on sait que l’intersection des médianes d’un triangle est aussi, physiquement, son centre de gravité, l’intersection des segments des centres de gravité pris deux à deux donne le centre de gravité de la plaque homogène ... qui n’est pas l’isobarycentre G des quatre points.

PNG

Les noms des différents isobarycentres ont été directement donnés par la macro. Ceci n’est pas faisable d’ordinaire dans les logiciels de géométrie dynamique.

Là on voit que c’est réalisable et de manière générique, par une procédure élémentaire, il suffit d’ajouter les noms des points cliqués dans le corps de la macro.

Note : cette activité est un prélude au théorème de Wittenbauer (plus d’actualité au lycée, mais encore en géométrie affine à l’université), Peut se traiter aussi par les homothéties.

1.7.d. L’aimantation dans les fichiers

Regardons le fichier associé à la macro sur l’alignement de points avec un point M aimanté par deux droites et un point.

Remarque ; on s’intéresse surtout à la macro de bibliothèque Alignement et à la syntaxe sur l’aimantation du point M. On laissera de côté, pour le moment, les expressions E1 et E11 produites par la macro alignement. On y reviendra dans la partie surles expressions.

// Coordinates System :
SetCoords(491,280.5,40);
// Geometry :
A=Point("A",-10.325,1.4375);
M=Point("M",-7.075,2.3125);
B=Point("B",-4.15,-0.1375);
F=Point("F",-2.275,2.1125);
E=Point("E",-8.675,-0.7625);
E11=Expression("E11","","","","var txt=\"Les points \"+M.getName()+\", \"+F.getName()+\" et \"+E.getName()+\" \";(abs(y((F-M)/(F-E)))<0.00000000001)?txt+\" sont align\u00e9s\":txt+\" ne sont pas align\u00e9s\"","-11.525","4.2625");
L2=Line("L2",F,E);
E1=Expression("E1","","","","var txt=\"Les points \"+A.getName()+\", \"+M.getName()+\" et \"+B.getName()+\" \";(abs(y((M-A)/(M-B)))<0.00000000001)?txt+\" sont align\u00e9s\":txt+\" ne sont pas align\u00e9s\"","-11.525","5.5125");
L1=Line("L1",A,B);
P1=OrderedIntersection("P1",L1,L2,0);
// Styles :
STL(A,"c:#007c00;o:1;s:4;sn:true;f:18;np:3.522099030702158");
STL(M,"c:#b40000;o:1;s:4;sn:true;f:18;mg:[L1,15],[L2,20],[P1,5]");
STL(B,"c:#007c00;o:1;s:4;sn:true;f:18;np:3.5886671944779818");
STL(F,"c:#0000b2;o:1;s:4;sn:true;f:18;np:1.360470453129839");
STL(E,"c:#0000b2;o:1;s:4;sn:true;f:18;np:1.2436982297891037");
STL(E11,"c:#0000b2;s:7;f:17;p:4;cL:200;cPT:YzojNzgwMDEzO3M6NDtmOjE4");
STL(L2,"c:#0000b2;s:1;f:30;p:0");
STL(E1,"c:#007c00;s:7;f:17;p:4;cL:200;cPT:YzojNzgwMDEzO3M6NDtmOjE4");
STL(L1,"c:#007c00;s:1;f:30;p:0");
STL(P1,"c:#0000b2;h:1;s:4;f:18");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

L’aimantation de M est dans la deuxième ligne de la partie Style.
D’un point de vue extérieur, l’aimantation se traduit par un simple paramètre qui recôit des listes d’objet et de rayon d’action de l’aimantation.

1.7.e. Exemple de la nécessité de modification d’une macro-construction

Ce paragraphe est plus technique, il n’intéressera que les personnes qui veulent acquérir une certaine efficacité dans la production des macro-constructions.

Lors de la construction de macros, la listes des objets finaux potentiels est mise à jour en permanence en fonction des dépendances des objets entre eux.

Si comme on l’a dit, c’est généralement pertinent, et souvent « cool » pour les utilisateurs (selon un vocabulaire de lycée), il reste que, parfois, même dans des situations tout à fait simples, on peut avoir à modifier des macros dans le fichier de la figure, en pratique les objets initiaux et légèrement l’ordenencement des objets. Voyons en un exemple archétypique : celui de la droite définie par deux points.

La situation choisie pour illustrer cette question est, possiblement, un contexte mathématique non usuel à l’utilisateur. Le contexte de la construction proposée est fondamentalement sans importance, ce qui compte c’est juste de percevoir que, compte tenu de la macro que l’on va faire, on va rencontrer un problème avec le comportement du logiciel vis à vis des macros et qu’il va falloir modifier cela à la main.

Construction d’une conique connaissant un point, deux tangentes et leur contact.

On l’a dit le contenu mathématique est sans importance ici, on peut ne pas le connaître, ce qui compte c’est l’articulation des macros en fonction du statut des objets. Mais on le précise pour celles et ceux qui veulent rentrer un peu plus dans la problématique.

PNG

On veut donc construire la conique passant par le point C, ayant pour tangentes les deux droites roses avec leurs points de contacts, ci-dessus, AB1 et BA1. Naturellement ces droites sont définies par ces points, mais si les points de contact avaient été des points sur objet des droites, le problème aurait persisté même si son traitement aurait été un peu différent.

Voir le principe de la construction (même si ce n’est pas utile à la compréhension de la situation quant aux macros)

• On va construire un quatrième point de la conique, le point C1.
• On pourra alors appliquer une autre macro-construction de coniques affines (résultat lié au théorème de Pascal) celle permettant de construire une conique connaissant 3 points -C, BA1 et C1 - une tangente et son contact : la droite rose passant par AB1.

La construction du point C1 :

• les deux tangentes roses se coupent en P.
• une droite quelconque d passant par P (ici on a pris la perpendiculaire à (C BA1) en P-
• La droite (C AB1) coupe d en M.
• La droite (C BA1) coupe (MP) en N.
• Alors - parce que M, N et P sont alignés - les droites (AB1 N) et (M BA1) se coupent en un point C1 de la conique.


Cette construction de la conique étant faite, on veut la transformer en macro. Les tangentes, comme droites, sont définies par deux points, respectivement AB1 et t1, puis BA1 et t2.

On se propose de donner comme objets initiaux, le point C, les tangentes et leurs contacts.

Mais c’est impossible, car les points AB1 et BA1 étant des points constituants des droites ils ne peuvent être donnés après les droites : car ce sont des DefinitionPoint des droites (notion dont on a dit quelle était essentielle à la qualité fine d’un micromonde).

On croit pouvoir s’en sortir en donnant les trois points et les deux tangentes dans le bon ordre. Mais cela ne fonctionne pas non plus, les objets initiaux et finaux sont remodifiés en temps réel au fur et à mesure des choix des objets initiaux, comme on l’illustre ci-dessous dans les deux premières lignes de ces copies d’écran :

Vous pouvez faire ces étapes et la modif en ligne - dans un éditeur de texte - en manipulant directement cette figure dans une nouvelle page.

• Étape 1 : on sélectionne les points C, AB1 et BA1, les seules objets finaux possibles sont L3 et L4.
• Étape 2 : on sélectionne ensuite la première tangente, L2. Aussitôt ses deux constituants - dont l’objet initial AB1 - passent en objets finaux,
• Étape 3 : puis en sélectionnant la seconde tangente, la droite L1, le point BA1 passe luis aussi en objets finaux (en fait constituants).
• Étape 4 : il n’y a plus qu’à terminer la macro construction pour la modifier.

Certes, bien entendu, une telle macro fonctionnerait, mais elle est loin de correspondre à ce que l’on attend en terme d’engagement direct : en effet il faudrait prévoir de signaler à l’utilisateur que le premier point constituant de chaque tangente DOIT ETRE le point de contact de la tangente à la conique : c’est juste inutilisable.

PNG

Le premier extrait de la macro correspond à ce que l’on vient de faire : on n’a que trois objets initiaux, un point et deux droites, et la macro commence par définir les points AB1 et BA1 comme les premiers constituants de chaque tangentes.

La modification à apporter est dans le dernier extrait de l’illustration ci-dessus : on ajoute deux points dans les paramètres, puis on ajoute les noms effectifs de ces points comme paramètres à la fonction (en respectant l’ordre souhaité), et on enlève les références aux points constituants dans le corps de la macro.
Avec cette modification, la macro correspond à ce que l’on voulait faire, elle fonctionne parfaitement, même si les points sont des constituants des droites.

Comme on le voit, dans plusieurs situations, mais essentiellement sur les points constituant de droites ou de cercles, on peut être amené à modifier les entêtes des macro-constructions. En pratique, cela ne sera jamais plus compliqué que ce qui vient d’être exposé dans cet exemple.

Haut de la barre d’interface

Partie 3D


2. Expressions - Curseurs - Traceur de courbe - Listes - Programmes

Les expressions sont un vaste domaine puisque, au dela de l’utilisation standard pour lesquelles elles ont été conçues (expressions algébriques, curseurs, traceurs, gestion des points 2D et 3D, calculs avec des nombres complexes), elle permettent aussi de faire des traitement de liste et d’inclure dans une expression, tout type de programme JavaScript, dont en particulier le traitement des apparences conditionnelles des objets.

On peut suivre la présentation et les activités - des copier coller d’expressions complexes sont proposées dans le corps du texte - en les réalisant sur la version webApp de DGPad dans une nouvelle fenêtre, typiquement dans un autre navigateur (par exemple en lisant l’article sous Firefox, Explorer ou Safari et en faisant l’activité sous Chrome ou Firefox : le clavier maths de DGPad est un peu trop grand pour être à l’intérieur du corps de texte d’un article SPIP, il est préférable de travaille dans une autre fenêtre.

Introduction

2.1.Introduction aux expressions - premières activités

Quand on lance le module d’expression (icone « calculatrice » du tableau de bord) le clavier de DGPad s’ouvre mais il est grisé, et on a une ligne d’expression. Il faut sélectionner cette ligne (clic ou doigt) pour que le clavier de DGPad devienne actif :

PNG

• En haut à gauche : une seule ligne d’expression, clavier grisé
• En haut au centre : quand on sélectionne la ligne d’expression, une seconde ligne, de texte, apparaît, et
• En haut à droite : en même temps à droite un domaine d’intervalle (min max) et trois icones : validation, fermeture, clavier.
• Au centre : la partie gauche du clavier, l’aspect mathématique
• En bas : la partie droite du clavier, l’aspect plus arithmétique.

Icone validation : il faut toujours valider une expression. On est piégé au début car l’expression est toujours évaluée en temps réel pour que l’on puisse vérifier que cela correspond à ce que l’on veux faire. Mais cette évaluation n’est en rien une validation. Faire autre chose que valider (en particulier changer d’icone du tableau de bord) annule tout ce qu’on vient de faire dans une expression.

Icone clavier : permet, sur tablette de basculer du clavier de DGPad (clavier mathématique) au clavier standard de la tablette pour taper un commentaire dans la ligne de texte ou simplement taper des noms de variables spécifiques.

Sur ordinateur, sélectionner l’icone clavier fait simplement enlever le clavier de DGPad. On peut alors utiliser le clavier de l’ordinateur. (En pratique tout fonctionne aussi directement sur le clavier de l’ordinateur sauf peut-être - surement sous MAC - la touche puissance ^.

Faire un coller : Pour coller une expression, venue du presse papier, dans la ligne d’expression il faut être en mode clavier standard, c’est-à-dire sans le clavier de DGPad à l’écran. L’icone clavier sert aussi à cette bascule.

Partie gauche du clavier  : on notera les expression toute prête sur les abcisses et ordonnées des points, mais on pourra aussi travailler sur la forme liste des points. On voit l’importance des nombres complexes. Les touches ? et : servent aux expressions simplifiées des tests IF THEN ELSE en JavaScript (sera détaillé plus loin)

Partie droite du clavier : les variables peuvent prendre tout type de nom, mais les lettres x, y, z et t sont reconnues comme privilégiées pour les expressions en particulier pour les tracés de fonction ou les dérivées.

2.1.a. Un premier curseur ....

On l’a vu, l’auteur est particulièrement sensible à l’anticipation des objets en cours de construction, et déjà, dans CaRMetal, quand il avait repris le coeur de C.a.R . il s’était attaché, dans son interface dite « Metal » (du metal brossé des interfaces Mac de cette époque) de produire la même qualité d’enticipation des outils et d’engagement direct dans les expressions que dans les objets géométriques, ce qui permet des activités de recherches et d’anticipation, au lycée en particulier, qu’on ne peux pas faire avec des logiciels dont les expressions ont un comportement modal, c’est-à-dire évaluée uniquement aprés avoir validé l’expression.

C’est la même chose avec DGPad : le rendu de l’expression réagit au fur et à mesure que l’on donne des informations ou que l’on tape une expression. C’est particulièrement signifiant, pour les élèves, dans le comportement « traceur de courbe », mais déjà dans un premier temps, voyons le sur la simple construction d’un curseur. Si vous faite un curseur dans un autre navigateur en lisant cette page, cela va plus vite à faire qu’à lire le commentaire qui suit cette illustration ;-)

PNG

Ligne 1 gauche : on a sélectionné simplement la ligne d’expression (clic de souris ou doigt). La ligne de texte apparaît ainsi que la partie à droite, vide, mais pas d’expression particulière.
Ligne 1 droite : en sélectionnant la ligne min et en entrant un nombre ...
Ligne 2 gauche : on a un retour - anticipation des constructions - sous la forme d’une expression qui attend une expression correcte (???)
Ligne 2 droite : en entrant une valeur dans la partie max, aussitôt ...
Ligne 3 gauche : l’expression est mise à jour sous forme d’un curseur (on a son tracé), mais non initialisé.
Ligne 3 droite : le rendu de l’expression est correct dés que le curseur a été initialisé dans la ligne de l’expression E1.

Cette simple séquence montrelle travail sur l’anticipation dans les expressions et l’engagement direct associé. Avec l’apprentissage de la construction d’un simple curseur on peut faire réagir les élèves, d’un point de vue algorithmique, sur la nécessité de l’initialisation d’une variable : l’élève voit très concrètement que la variable E1 (un curseur) attend (???) son initialisation.

Aspects du curseur, réglages et texte de commentaire

En utilisant les deux curseurs des patrons du cube, sur la première figure de cet article, vous avez remarqué que celui du numéro de patron est un entier alors que celui de l’ouverture est « continu ».

La définition d’une expression comporte deux lignes, son expression proprement dite (précédé de son nom de variable) et un commentaire associé : c’est ce commentaire qui est affiche sur le curseur.

Les curseurs, comme expressions, ont accès à l’inspecteur d’objets. On peut modifier son nom de variable, choisir la taille de police, pour le commentaire, fixer sa précision (choisir sans pour cacher la valeur numérique) et lui fixer un incrément.

En particulier, un curseur allant de 0 à 1 avec un incrément de 1 est un curseur booléen qui peut faire office de case à cocher.

2.1.b. ... et une première courbe.

Poursuivons avec notre curseur,. Si vous faites la figure en même temps, lui donner le nom a (dans l’aspect des objets). Déplacer la position du curseur pour la prochaine expression qui va s’afficher au même endroit initial. On prend une nouvelle expression et on effectue les manipulations suivantes, illustrées ci-dessous :

Ligne 1a : on entre dans la nouvelle expression le nom du curseur. Il est réglé sur 1, E1 est affichée à 1.
Ligne 1b : puis on multiplie a. Dés que l’on sélectionne * pour le signe « multiplié » l’expression, qui était jusque là numérique, est non évaluée (???) en attente du second facteur.
Ligne 1.c : on sélectionne x au clavier de DGPad (ce serait au clavier physique d’un ordinateur cela fonctionnerait aussi), alors le module expression bascule d’un comportement numérique à un comportement algébrique, reconnaît la variable, évalue l’expression comme valide algébriquement ...
Ligne 1d  : et - nouvelle démarche d’anticipation - affiche, à côté de l’icone verte de validation, l’icone d’un tracé de courbe.

On voit donc une adaptation en temps réel de l’environnement à la situation algébrique et potentiellement graphique. Et la finesse de l’engagement direct ne s’arrête pas là.

Ligne 2.a : on veut entrer l’expression a*x+1. Dés que l’on ajoute le signe + à l’expression, d’une part l’icone de tracé de courbe disparaît (non illustré ici) mais l’expression E1, puisque l’on est maintenant dans un mode algébrique n’affiche pas une attente d’évaluation (???) comme précédemment, mais attend simplement le second terme de la somme avant une évaluation algébrique : le module expression prend en compte et anticipe l’intention de l’utilisateur.
Ligne 2.b : on a complété l’expression. Elle est interprétée comme algébriquement valide et donc propose à nouveau le tracé.

PNG

Ligne 3 (le graphique) : le tracé de la droite y=ax+1 est effectué, par l’icone de représentation graphique. Si on clique sur la courbe, elle s’appelle f1 et f1(x) est égal à E1(x). En particulier, à ce stade, on ne supprime pas l’expression E1, sinon cela supprime la courbe.

Remarque : on verra que ce sera différent pour les points : si on construit un point avec une expression, le tracé du point fait supprimer l’expression. Là on est à un niveau un peu plus complexe.

Ligne 4.a : une courbe étant tracée, pour cette expression, les bornes min et max prennent alors un sens mathématiquement différent que les bornes d’un curseur , celui de l’intervalle de définition d’une fonction (de la variable x implicitement reconnue) et là encore l’environnement s’adapte à cette situation : en renseignant les bornes min et max, la représentation graphique s’adapte.
Ligne 4b. Et si on prend un point sur objet de la courbe, son amplitude est limitée par les bornes et s’adapte si on modifie ces bornes aprés la création de ce point sur objet.

2.1.c. Pas de signe entre nombre et variables

Pour le produit d’un nombre avec une des variables du clavier de DGPad (x, y, z, t), il n’est pas nécessaire de mettre un signe de multiplication : l’interpréteur comprend très bien 2x+1 ou autres expressions algébriques. On observera la discontinuité de la suite « sans icone de représentation », « avec l’icone » dans cette illustration au passage de « +3 » à « +3x » :

PNG

Mais comme on l’a vu, il faut ajouter le signe * dans le cas d’une expression. Ci dessous, on modifie le 3 précédent par le curseur E2. Dans un premier temps (encadré) avec E2 à la place de 3 on a E2x, et pas de tracé, mais dès qu’on ajoute le signe * (second encadré) le tracé est à nouveau anticipé. Il faut bien entendu valider la modification.

PNG

Parfois on peut commencer implicitement l’exploration de la construction avant même cette validation. Par exemple ci-dessous, on peut facilement conjecturer la valeur de E2 pour que cette fonction spécifique, dépendant de E2 ait une racine double ... (ici image en taille réelle)

PNG

La présence de l’icone de représentation graphique montre bien qu’on a commencé l’exploration (en déplaçant le curseur) avant même d’avoir validé la modification.

Il faut être vigilant au début de l’utilisation : ne pas oublier de valider.

Haut de la barre des expressions

Retour à l’interface

Points et expressions

2.2. Opérations diverses sur les points

Les points sont, essentiellement, des listes, de deux nombres pour le plan et de trois nombres pour l’espace, mais pour le moment, nous ne travaillons que dans le plan. Il suffit de définir sur ces listes les opérations somme et produit appropriées pour en faire aussi des nombres complexes.

2.2.a. Création de points par une expression

Commençons par les sommes de points :

PNG

En haut à gauche : on additionne deux points, simplement par leurs noms.
En haut à droite : une icone Point apparaît à gauche de l’icone de validation
En bas à gauche : en cliquant sur cette icone Point, on construit le point, et en même temps on détruit l’expression qui l’a créé (elle est passée dans la définition du point). Ici on a ajouté le nom AplusB avec l’inspecteur d’objet.
En bas à droite : on vérifie que le point créé est bien le 4° point du parallélogramme avec l’origine en calculant à l’envers le 4° point du parralélogramme de sommets A, AplusB, B : on trouve l’origine du repère.


On retiendra de cette illustration

• Contrairement aux représentations graphiques, la validation d’un point par expression supprime l’expression (elle devient la définition du point).
• Pour construire le point D quatrième point du parallélogramme ABCD il suffit de définir D comme A+C-B.

L’écriture de D ci dessus est conforme à la notation de Grassmann, mais ici nous sommes dans un travail sur les expressions algébriques, les écritures seront valides au delà de cette notation.

Poursuivons notre exploration de points avec des outils plus « nombres complexes ». On a vu qu’au clavier des expressions, on dispose des touches conjugué et argument. Dans lillustration suivante, on a nommé Ab (pour « A barre ») le conjugué de A et Bb celui de B. Le point nommé AB est simplement le produit A*B, et on compare conj(AB) avec Ab*Bb.

PNG

2.2.c. Traitement d’exercices classiques avec les complexes

Dans ce paragraphe, on revisite quelques trés classiques exercices, et on les traite avec les complexes. Les figures sont faites avec la macro Carré du logiciel. Pour les personnes qui veulent s’entrainer en ligne sur les expressions, les figures sont proposées ouvrables dans le navigateur, en dehors du cadre de l’article pour mieux accéder au clavier de DGPad. On rappel que sur ordinateur on peut utiliser le clavier de l’ordinateur. Dans tous les cas c’est plus pratique d’ouvrir la figure dans un autre navigateur.

Exercice 1

On se donne deux carrés de même sommet (ci-dessous ABCD et AEFG) complété de deux parallélogrammes AGSB et ADRE. On veut illustrer que les centres de ces quatre parallélogrammes forment un carré.

Vous pouvez faire des conjectures géométriques ou les calculs d’expression sur cette figure : http://goo.gl/n0b9OM

PNG

La première expression vérifie que c’est un parallélogramme et la seconde que [NP] et [NM] sont orthogonales ... et de même longueur.

Je vous invite à tester ce que feront nécessairement quelques élèves si on leur faisait faire cette activité : (M-N)/(P-N). Comment interpréter le résultat ? Même si c’est tout à fait correct - puisque ce n’est que la division de nombres complexes dans le corps des complexes - on évitera toutefois de favoriser cette procédure.

Dans une démarche comme celle-ci, nous ne sommes que dans une démarche de conjecture - comme on le serait sur un tableur avec des activités numériques. Il conviendrait de montrer le résultat avec du calcul (par exemple formel).

Exercice 2

Vous pouvez faire des conjectures et les calculs d’expression sur cette figure : http://goo.gl/OVN95R

On se donne un quadrilatère ABCD sur lequel on fait des carrés extéreurs, de centre M,N, P et Q. On se propose de vérifier, par le calcul sur les nombres complexes, que [MP] et [NQ] sont orthogonaux et de même longueur. On s’intéresse aussi au cas où ABCD est un parallélogramme.

PNG

En ligne, penser à placer D sur le point S. En déduire la nature de MNPQ.

On l’a déjà dit, ces calculs numériques ne remplacent pas un vrai calcul algébrique, comme par exemple celui-ci (formation à wxMaxima, ... peut se faire sans fonction)

PNG

Caractérisation de ABC équilatéral

Figure en ligne que vous pouvez manipuler (déplacer M, A ou B)


Haut de la barre des expressions

Retour à l’interface

Points et booléens

Cet onglet va être consacré à une activité de construction géométrique simple, utilisable au lycée en particulier comme exercice de logique. Cet exercice a déjà été proposé sur le site de l’IREM dans cet article (mai 2009) avec des applets CaRMetal dont on sait qu’elles sont difficiles à lire depuis les modifications de politique de Oracle vis à vis de Java.

C’est l’occasion de refaire l’exercice, car comme nous sommes dans un autre environnement, il va se faire avec un autre traitement des points : nous allons utiliser directement des combinaisons linéaires booléenes de points. Dis comme cela c’est un peu savant, c’est un vocabulaire pour enseignant, pour préciser le concept sous-jacent. C’est une méthode générale très efficace pour éviter les tests conditionnels emboités (souvent compliqués à concevoir et lourds à écrire pour les élèves).

2.3.a. Activité proposée et principe de résolution


Étant donné un triangle ABC, on se propose de construire le plus petit cercle contenant les points A, B et C.

Si on ne fait plus trop de géométrie au lycée, on est invité par les programme à parler de logique. On va en parler ici dans deux directions :
un aspect opérationnel pour trouver une construction simple.
un aspect conceptuel : construire un unique objet (logique) solution qui sait rendre compte des différents « cas de figure » qui apparaissent dans une démonstration : les constructions logiques vont permettre de construire effectivement un unique cercle correspondant à la solution mathématique du problème.

La surprise passée - a priori cela ne doit pas être toujours le cercle circonscrit sinon on ne poserait pas ce problème - on commence à observer une figure, par exemple celle-ci (un peu préparée pour aller plus vite).

Phase 1. Exploration de la situation

Déjà on peut faire passer le cercle par un sommet car tant qu’il ne touche pas un point on peut diminuer son rayon. Faisons passer le cercle par un sommet, le point A.
Explorons la figure suivante (manipulable dans l’article)


Bilan de la phase précédente - conjecture

On a pu observer que
• Si les trois angles sont aigus, le cercle solution est le cercle circonscrit.
• Sinon c’est le cercle de centre le milieu du côté opposé à l’angle obtus.

Note : quand on fait faire cette activité, ce qui ressort assez souvent c’est que le centre du cercle n’est pas en O (centre du cercle circonscrit) quand O est à l’extérieur du triangle. C’est assurément une belle observation, mais elle n’est pas opérationnelle. Il faut alors recentrer la question sur la place du centre du cercle : quand est-il en O et surtout en I, J ou K : un autre point de vue, trivial mais qui va être pertinent, est d’observer qu’il sera en O quand il ne sera ni en I, ni en J , ni en K.

Cette conjecture, une fois mise en évidence est facile à prouver, sur la base des propriétés du cercle et des angles (angle droit et diamètre). Mais cela peut ne pas être l’objectif principal de l’activité qui est centrée sur une construction logique.

2.3.b. Opérationalisation de ce qui précède

Le cercle solution va être décrit par son centre U et un point de ce cercle, notons le V.
Il convient maintenant de placer des marqueurs sur la figure pour dire quand ce point U, centre du cercle solution va entre en O, en I en J ou en K et par quel point V de la figure le cercle solution va passer.

Pour poursuivre la construction en ligne, vous êtes invités à ouvrir la figure suivante dans une nouvelle fenêtre : http://goo.gl/Wk8hnw

Les angles en A, B et C se nomment aA, aB et aC. S’ils sont affichés en degrés dans les triangles, car c’est l’unité usuelle en collège en particulier, comme expression - pour une utilisation avec les fonctions trigonométriques - elles sont en radians.

Phase 2. Lecture opérationnelle des éléments de la conjecture

Le point U est :
• en I si aC > 90
• en J si aA > 90
• en K si aB > 90
• en O s’il n’est dans aucun des cas précédents.

On créé donc des expressions - que l’on va nommer (par l’inspecteur d’objet) EnI, EnJ, EnK qui sont les expressions précédentes écrites en radians, respectivement aC > π/2, aA > π/2 et aB > π/2. (utiliser la touche π du clavier ou écrire PI)

PNG

Quelle valeur logique pour EnO ?

Si on dit que U est en O ssi il n’est pas dans une autre position, il faudrait écrire - en logique - EnO=non(EnI ou EnJ ou EnK) ce qui s’écrit aussi, avec les opérateurs logiques de JavaScript ,EnO= !(EnI || EnJ || EnK). Bien entendu une telle écriture n’est pas réaliste en classe (mais utilisable en formation des enseignants).

Une autre façon d’écrire EnO est de remarquer que EnI, EnJ et EnK s’ils ne sont pas nul ne sont jamais égaux à 1 en même temps (il n’y a qu’un angle obtus). Ainsi alors qu’on devrait traduire que EnO est vrai si les 3 autres sont faux par EnO=(1-EnI)*(1-EnJ)*(1-EnK), on peut simplifier cette écriture par un simple EnO=1-EnI-EnJ-EnK car cette expression sera nulle dés que l’un des trois booléens est nul et sera égal à 1 si les trois sont nuls.

2.3.c. Construction du cercle solution

À partir de ces booléens on peut construire U comme étant I si EnI est égal à 1, J si EnJ est égal à 1 ...etc ... d’où cette écriture : U=EnI*I+EnJ*J+EnK*K+EnO*O.

PNG

Ainsi, on a construit un seul point, U, et ce point prend les positions qu’il convient selon le contexte de la figure. On remarquera que si on devait imbriquer quatre tests conditionnels, ce serait autrement plus complexe à écrire.

Sur l’illustration précédente, on voit aussi que le point V peut être - entre de nombreuses possibilités - par exemple V= (EnJ+EnO)*B+(EnI+EnK)*A.

Figure finale manipulable en ligne :


Comme annoncé en début d’onglet, il y a, dans cette activité, de la logique
a) d’un point de vue conceptuel : construire un unique cercle alors qu’il y a quatre cas distincts,
b) d’un point de vue opérationnel par l’utilisation de ces quatre booléens intermédiaires.

Remarque pour les Geogebristes : bien entendu tout ce qui précède fonctionne parfaitement avec GeoGebra.

2.3.d. Version plus compacte par traitement d’une liste

Même si on n’utilisera pas cela en formation - et encore moins au lycée - pour être complet, on peut remarquer qu’on aurait pu avoir une seule liste de booléens, comme :

IJKO=[aC > π/2, aA > π/2, aB > π/2, 1-(aC > π/2)-(aA > π/2)-(aB > π/2)]

et l’utiliser, dans les définitions de U et V sous la forme

U = IJKO[0]*I+IJKO[1]*J+IJKO[2]*K+IJKO[3]*O et
V=(IJKO[1]+IJKO[3])*B+(IJKO[0]+IJKO[2])*A.

Haut de la barre des expressions

Retour à l’interface

Expressions et fonctions

2.4. Exemples d’utilisation des expressions dans des représentations graphiques.

On ne donne ici que qelques exemples qui ne sont que des pistes d’utilisation, pour illustrer ce que l’on peut faire avec les expressions.

2.4.a. Les représentations paramétriques.

Comme un point du plan est une liste de deux termes, si ces deux termes dépendent d’une même variable (reconnue automatiquement par DGPad), on a une courbe paramétrée. Par exemple :

Trois exemples du Jardin des Courbes - Hamza KHELIF - Ed. Ellipses (on peut déplacer le curseur en ligne)


On notera que le signe produit est souvent non nécessaire dans les écritures algébriques.



2.4.b. Parabole et calcul formel.

Revenons à des choses moins exotiques. On se construire les tangentes communes à deux paraboles. C’est un exercice classique de lycée, mais généralement proposé dans un cadre numérique précis. On va l’aborder ici dans un cadre algébrique général, en particulier en utilisant du calcul formel. Si la première partie n’est directement accessible au lycée, on peut faire les modifications proposées ou donner une figure pré-construite pour poser la réflexion quant à la seconde partie.

Ici comme on veux travailler les fonctions et les expressions de DGPad, on traite toute l’activité, comme en formation initiale des enseignants (sous GGB pour la préparation à l’oral des concours)

Etape 1 : construction d’une fonction du second degré connaissant 3 points.

Cet étape est un classique de TICE en formation initiale des enseignants. On peut considérer qu’elle ne relève pas du lycée (mais possiblement du BTS selon les options) et donc, soit donner aux élèves de lycée une figure initiale avec la construction de deux paraboles, soit encore faire faire deux paraboles avec 6 curseurs, mais c’est à la fois moins esthétique et surtout nettement moins en engagement direct puisque l’on manipule des coefficients plutôt que des points qui définissent aussi bien la courbe.

Il s’agit bien d’une fonction du second degré, pas vraiment d’une parabole car par trois points il passe une infinité de paraboles. Mais il n’y a qu’une seule parabole dont l’axe est de direction fixe (ici l’axe des ordonnées).

Si on cherche une fonction du type y=ax^2+bx+x passant par trois points A(x(A),y(A)), B(x(B),y(B)), et C(x(C),y(C)), on doit rechercher a, b, c solution du système linéaire :

\left{{\begin{array}{*{20}{c}}
{ax{{(A)}^2} + bx(A) + c = y(A)}\\
{ax{{(B)}^2} + bx(B) + c = y(B)}\\
{ax{{(C)}^2} + bx(C) + c = y(C)}
\end{array}

Ce qui est intéressant ici c’est que les paramètres peuvent s’écrire directement x(A) etc ... D’où la solution proposée par wxMaxima, directement copiable dans les logiciels de géométrie dynamique : GeoGebra, CaRMetal, DGPad entre autres.

PNG

Ce qui permet de construire une parabole plutôt par trois points que par trois curseurs.

Remarques :
• Dans les copier/coller vers les logiciels, il peut y avoir des retours à la ligne, il faut les repérer et les enlever. Passer par un petit éditeur de texte par exemple pour faire cela rapidement.

Dans la figure ci-dessous, penser à déplacer un des points des paraboles si elles ne sont pas dessinées à l’ouverture - peut dépendre du navigateur.


On transforme cette figure en macro-construction et on obtient ainsi rapidement deux paraboles définies chacune par trois points.

Etape 2 : les tangentes communes à deux paraboles.

Il y a plusieurs façons d’aborder cette question. On peut déjà explorer la figure pour conjecturer que, sauf quand l’une est contenue à l’intérieur de l’autre et sauf cas exotiques - paraboles elles-mêmes tangentes par exemple - deux paraboles ont en général deux tangentes communes.

Une première recherche - un peu lourde - pourrait consister à chercher des abscisses x_1 et x_2, de points M_1 et M_2 respectivement de la première et seconde parabole telle que la droite (M_1M_2) soit une tangente commune aux deux paraboles, ce qui s’exprime par le fait que les tangentes - en M_1 à la première parabole, en M_2 à la seconde - soient de même pente.

C’est un peu lourd, mais c’est très naturellement vers cela que se dirigent les étudiants en formation. On peut facilement imaginer qu’elle puisse donc être aussi assez naturelle chez les élèves. Mais l’écriture des tâches succesives est rapidement chronophage, sauf à l’organiser sous forme de narration de recherche ou de tâches complexes à travailler en groupe.

Voir la résolution par cette méthode

Exemple de production d’étudiant (exposé TICE 2012)

PNG


Une deuxième méthode : une méthode plus rapide, et plus fine dans l’utilisation des outils de 1°S - mais assurément moins naturelle à des élèves qui découvrent les arguments algébriques en analyse - consiste à chercher l’abscisse x_M d’un point M de la première parabole dont la tangente en M couperait la seconde parabole en « une racine double ». Cette piste lancée, on s’attend à ce que la « racine double » fasse penser à un discréminant nul, et donc que les élèves prennent peu à peu conscience que l’intersection d’une tangente à la première parabole et de la seconde parabole est une équation du second degré qui peut avoir aucune racine, deux, ou une racine double. C’est ce cas qui nous intéresse. Ce qui fait fonctionner l’usage du discréminant nul d’une manière plus originale que ce que l’on fait traditionnellement.

Techniquement, une fois la tâche comprise, cette solution est bien plus rapide à écrire que la précédente.


Comparaison des deux résultats.

On peut observer que les deux valeurs des abscisses, x_{p_1} et x_M, produites par le logiciel wxMaxima sont bien les mêmes. Dans la première version, ce qui est très déstabilisant et didactiquement non pertinent (mais on peut rebondir aussi sur cette difficulté), ce sont les racines carrées de a_1 et de a_2 dans les expressions des solutions de x_{q_1}, alors qu’en général l’une des valeurs est négative. En fait c’est une simplification un peu trop forte du logiciel : en pratique il y a un terme sous la racine (dans x_{p_1} et x_M) et ce terme est positif quand il y a deux tangentes.

Écriture du résultat (version 2)

En définitive les calculs se simplifient grandement par factorisation. Une fois les points M et U trouvés sur la première parabole, il est très simple de calculer les points de contact avec la seconde parabole (respectivement N et V) en écrivant justement, mais seulement à ce moment là, que les pentes des tangentes sont les mêmes : on vient de calculer x_M, alors x_N vérifie tout simplement 2a_2x_N+b_2=2a_1x_M+b_1, de même pour le point V. On a donc les tangentes par les deux points de contact.


La figure finale

Penser à déplacer un des points des paraboles si elles ne sont pas dessinées à l’ouverture - peut dépendre du navigateur.


Aller un peu plus loin

On peut revenir un instant - mais pas en classe - sur le signe du paramètre appelé t dans la figure précédente.

t = a_1a_2[(b_2-b_1)^2-4(a_2-a_1)(c_2-c_1)] que l’on va écrire aussi a_2a_1\Delta

avec \Delta le discréminant de f_2(x)-f_1(x)=0

On peut obsevser - cela resterait à montrer plus en détail - les résultats suivants :

Si \Delta <0, les deux paraboles sont disjointes.
• Quand a_2a_1 >0 l’une est à l’intérieur de l’autre, elle n’ont pas de tangentes communes, et t<0.
• Quand a_2a_1 <0 l’une des courbes représentatives est concave l’autre est convexe, elle auront des tangentes communes, et t>0.

Si \Delta >0, les deux paraboles sont sécantes.
• Avec a_2a_1 >0 les courbes ont même concavité, les paraboles ont des tangentes communes, et t>0.
• Avec a_2a_1 <0 elles sont sécantes tout en n’ayant pas la même concavité, elle ne peuvent avoir de tangentes communes, et t<0.

On voit donc que le signe de t est caratéristique de l’existence de tangentes communes.

Reste à traiter, et à illustrer, le cas \Delta = 0 : les paraboles ont une tangente commune double en le point d’abscisse \frac{b_1-b_2}{2(a_2-a_1)}

C’est l’objet du prochain paragraphe (dans une version scolaire et une non scolaire)

2.4.c. Cas des paraboles tangentes.


La version scolaire : paraboles construites avec des curseurs

Dans le cadre de l’utilisation du discréminant nul à des fins de conceptualisation algébrique, il peut être intéressant de faire chercher à quelles conditions sur les coefficients des polynômes du second degré, deux paraboles vont être tangentes. On trouve, comme ci-dessus que le discréminant Delta = (b_2-b_1)^2-4(a_2-a_1)(c_2-c_1) doit être nul ce qui donne tout de suite c_2 en fonction des cinq autres pramétres s’ils sont connus.

Pour mette cela en valeur sans complication particulière, on peut utiliser des curseurs plutôt que des points. C’est alors immédiat à faire, y compris par des élèves (même s’il faut un peu de temps quand même ;-).

Penser à déplacer un des curseurs si les paraboles ne sont pas dessinées à l’ouverture - peut dépendre du navigateur.


En comparaison avec la version sans curseur, on voit bien que cette version - d’un coût technique minimal - n’a pas le même engagement direct que la version avec des points.

Elle a néanmoins des intérêts spécifique pour voir l’influence d’un paramètre, les autres restant fixes.

La version non scolaire : paraboles définies par des points

Pour chercher le cas particulier des tangentes communes confondues - c’est-à-dire des paraboles tangentes - on s’intéresse à une parabole déjà construite et la seconde passant par deux points P et Q et un point de contact M d’une tangente commune. En fait la situation va être plus complexes qu’avec les curseurs car il va y avoir deux solutions.

Le problème est facile à poser puisque l’on connait le point de contact en fonction des coefficients. La solution est néanmoins moins simple que dans le cas précédent, car il y a interaction entre ces coefficients et la solution du contact M. En fait comme de plus il y a deux solutions, il est intéressant, pour optimiser les calculs des coefficients de chercher des relations (même partielles) entre ces deux solutions.

Pour ceux qui veulent finaliser la figure eux-mêmes vous pouvez le faire en ligne en partant de cette construction (nouvelle fenêtre) : http://goo.gl/6jNhKT
Dans les données du bloc ci-dessous, vous utiliserez successivement suv, puis les écritures simplifiées de a_{21}, b_{21}, c_{21} pour construire la fonction trinôme associée à la première solution. Il faudra ajouter quelques variables intermédiaires supplémentaires, communes aux deux solutions. La seconde parabole est données par les expressions simplifiées de a_{22}, b_{22}, c_{22}
On peut ajouter les point de contact M et N. Par exemple M est point d’abscisse x_M =\frac{b_1-b_{21}}{2(a_{21}-a_1)} et d’ordonnée f_1(x_M). De même, N est d’abscisse x_N =\frac{b_1-b_{22}}{2(a_{22}-a_1)}

Le détail du calcul des deux solutions


a) l’écriture brute

présenté ici pour « la première solution » (le point M de la figure)

PNG


b) Une transcription utilisable en géométrie dynamique

En pratique on repère deux expressions, sous les racines carrées, nommées su et sv ci-dessous mais qui sont des racines carrées formelles, leurs radicandes sont des nombres négatifs. Or on s’aperçoit que, dans tous les cas, les deux termes se factorisent, ensemble. On introduit alors le produit, nommé suv ci-dessous, qui est bien la racine carré d’un nombre positif.

Pour la réalisation de la solution, il n’y a que suv à mettre dans la figure, su et sv sont inutiles.

Bizarrement on remarquera que la séparation de suv en su et sv n’a pas été faite par le logiciel dans le calcul des coefficients a_{21} et a_{22}.

Paraboles tangentes
une première parabole est définie par trois points, on a déjà calculé les coefficients a1, b1, c1,
l'autre parabole est définie par deux points P et Q et le point de contact M.

wxMaxima donne deux solutions

L'exercice consiste surtout à retravailler les solutions données par wxMaxima, non directement exploitable.

On pose :

su=sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)

sv=sqrt(y(Q)-a1*x(Q)^2-b1*x(Q)-c1)

suv=sqrt((y(P)-a1*x(P)^2-b1*x(P)-c1)*(y(Q)-a1*x(Q)^2-b1*x(Q)-c1))

--------- coef a - directement interprétable

sol 1 : a31

(2*sqrt((y(P)-a1*x(P)^2-b1*x(P)-c1)*y(Q)+(-a1*y(P)+a1^2*x(P)^2+a1*b1*x(P)+a1*c1)*x(Q)^2+(-b1*y(P)+a1*b1*x(P)^2+b1^2*x(P)+b1*c1)*x(Q)-c1*y(P)+a1*c1*x(P)^2+b1*c1*x(P)+c1^2)+y(Q)+(-2*a1*x(P)-b1)*x(Q)+y(P)-b1*x(P)-2*c1)/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

sol 2 : a32

-(2*sqrt((y(P)-a1*x(P)^2-b1*x(P)-c1)*y(Q)+(-a1*y(P)+a1^2*x(P)^2+a1*b1*x(P)+a1*c1)*x(Q)^2+(-b1*y(P)+a1*b1*x(P)^2+b1^2*x(P)+b1*c1)*x(Q)-c1*y(P)+a1*c1*x(P)^2+b1*c1*x(P)+c1^2)-y(Q)+(2*a1*x(P)+b1)*x(Q)-y(P)+b1*x(P)+2*c1)/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

Simplification

NumA3b = y(Q)+(-2*a1*x(P)-b1)*x(Q)+y(P)-b1*x(P)-2*c1

DenA3B3 = (x(Q)-x(P))^2

a31 = (2*suv+NumA3b)/DenA3B3

a32 = -(2*suv-NumA3b)/DenA3B3

--------- coef b - à réécrire car les radicandes de su et sv peuvent être négatifs mais se factorisent ensemble

sol 1 : b21

-((2*su*x(Q)+2*x(P)*su)*sv+2*x(P)*y(Q)+(-2*a1*x(P)-b1)*x(Q)^2+(2*y(P)-2*a1*x(P)^2-2*b1*x(P)-2*c1)*x(Q)-b1*x(P)^2-2*c1*x(P))/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

sol 1 : b21 avec une fois l'expression de suv

-(2*(x(Q)+x(P))*suv+2*x(P)*y(Q)+(-2*a1*x(P)-b1)*x(Q)^2+(2*y(P)-2*a1*x(P)^2-2*b1*x(P)-2*c1)*x(Q)-b1*x(P)^2-2*c1*x(P))/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

simplification b21

((x(P)+x(Q))*(2*c1-2*suv+2*a1*x(P)*x(Q)+b1*(x(P)+x(Q)))-2*(x(P)*y(Q)+y(P)*x(Q)))/DenA3B3

sol 2 : b22 version initiale

((2*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*x(Q)+2*x(P)*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1))*sqrt(y(Q)-a1*x(Q)^2-b1*x(Q)-c1)-2*x(P)*y(Q)+(2*a1*x(P)+b1)*x(Q)^2+(-2*y(P)+2*a1*x(P)^2+2*b1*x(P)+2*c1)*x(Q)+b1*x(P)^2+2*c1*x(P))/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

b22 avec suv :

(2*(x(Q)+x(P))*suv-2*x(P)*y(Q)+(2*a1*x(P)+b1)*x(Q)^2+(-2*y(P)+2*a1*x(P)^2+2*b1*x(P)+2*c1)*x(Q)+b1*x(P)^2+2*c1*x(P))/(x(Q)^2-2*x(P)*x(Q)+x(P)^2)

simplification b22

((x(P)+x(Q))*(2*suv+2*c1+2*a1*x(P)*x(Q)+b1*(x(Q)+x(P)))-2*(x(P)*y(Q)+x(Q)*y(P)))/DenA3B3



----- Le coefficient c

----- Sol 1 : c21

(x(P)^2*y(Q)^2+sv*((2*x(P)*su*x(Q)+2*x(P)^2*su)*y(Q)-2*a1*x(P)*su*x(Q)^3+su*(2*y(P)-4*a1*x(P)^2-4*b1*x(P))*x(Q)^2+su*(2*x(P)*y(P)-2*a1*x(P)^3-4*b1*x(P)^2-8*c1*x(P))*x(Q))+((y(P)-3*a1*x(P)^2-b1*x(P))*x(Q)^2+(4*x(P)*y(P)-4*a1*x(P)^3-6*b1*x(P)^2-6*c1*x(P))*x(Q)+x(P)^2*y(P)-a1*x(P)^4-b1*x(P)^3-2*c1*x(P)^2)*y(Q)+(-a1*y(P)+2*a1^2*x(P)^2+a1*b1*x(P))*x(Q)^4+((-4*a1*x(P)-b1)*y(P)+4*a1^2*x(P)^3+7*a1*b1*x(P)^2+(6*a1*c1+b1^2)*x(P))*x(Q)^3+(y(P)^2+(-3*a1*x(P)^2-6*b1*x(P)-2*c1)*y(P)+2*a1^2*x(P)^4+7*a1*b1*x(P)^3+(4*a1*c1+6*b1^2)*x(P)^2+8*b1*c1*x(P))*x(Q)^2+((-b1*x(P)^2-6*c1*x(P))*y(P)+a1*b1*x(P)^4+(6*a1*c1+b1^2)*x(P)^3+8*b1*c1*x(P)^2+8*c1^2*x(P))*x(Q))/((2*su*x(Q)^2-4*x(P)*su*x(Q)+2*x(P)^2*su)*sv+(x(Q)^2-2*x(P)*x(Q)+x(P)^2)*y(Q)-a1*x(Q)^4+(2*a1*x(P)-b1)*x(Q)^3+(y(P)-2*a1*x(P)^2+b1*x(P)-2*c1)*x(Q)^2+(-2*x(P)*y(P)+2*a1*x(P)^3+b1*x(P)^2+4*c1*x(P))*x(Q)+x(P)^2*y(P)-a1*x(P)^4-b1*x(P)^3-2*c1*x(P)^2)

------ Sol 2 : c22

sol 2 : c22

(-x(P)^2*y(Q)^2+sqrt(y(Q)-a1*x(Q)^2-b1*x(Q)-c1)*((2*x(P)*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*x(Q)+2*x(P)^2*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1))*y(Q)-2*a1*x(P)*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*x(Q)^3+sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*(2*y(P)-4*a1*x(P)^2-4*b1*x(P))*x(Q)^2+sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*(2*x(P)*y(P)-2*a1*x(P)^3-4*b1*x(P)^2-8*c1*x(P))*x(Q))+((-y(P)+3*a1*x(P)^2+b1*x(P))*x(Q)^2+(-4*x(P)*y(P)+4*a1*x(P)^3+6*b1*x(P)^2+6*c1*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+2*c1*x(P)^2)*y(Q)+(a1*y(P)-2*a1^2*x(P)^2-a1*b1*x(P))*x(Q)^4+((4*a1*x(P)+b1)*y(P)-4*a1^2*x(P)^3-7*a1*b1*x(P)^2+(-6*a1*c1-b1^2)*x(P))*x(Q)^3+(-y(P)^2+(3*a1*x(P)^2+6*b1*x(P)+2*c1)*y(P)-2*a1^2*x(P)^4-7*a1*b1*x(P)^3+(-4*a1*c1-6*b1^2)*x(P)^2-8*b1*c1*x(P))*x(Q)^2+((b1*x(P)^2+6*c1*x(P))*y(P)-a1*b1*x(P)^4+(-6*a1*c1-b1^2)*x(P)^3-8*b1*c1*x(P)^2-8*c1^2*x(P))*x(Q))/((2*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*x(Q)^2-4*x(P)*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1)*x(Q)+2*x(P)^2*sqrt(y(P)-a1*x(P)^2-b1*x(P)-c1))*sqrt(y(Q)-a1*x(Q)^2-b1*x(Q)-c1)+(-x(Q)^2+2*x(P)*x(Q)-x(P)^2)*y(Q)+a1*x(Q)^4+(b1-2*a1*x(P))*x(Q)^3+(-y(P)+2*a1*x(P)^2-b1*x(P)+2*c1)*x(Q)^2+(2*x(P)*y(P)-2*a1*x(P)^3-b1*x(P)^2-4*c1*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+2*c1*x(P)^2)



---- Expression du numérateur de c21 avec su et sv

x(P)^2*y(Q)^2+((y(P)-3*a1*x(P)^2-b1*x(P))*x(Q)^2+(4*x(P)*y(P)-4*a1*x(P)^3-6*b1*x(P)^2+(2*su*sv-6*c1)*x(P))*x(Q)+x(P)^2*y(P)-a1*x(P)^4-b1*x(P)^3+(2*su*sv-2*c1)*x(P)^2)*y(Q)+(-a1*y(P)+2*a1^2*x(P)^2+a1*b1*x(P))*x(Q)^4+((-4*a1*x(P)-b1)*y(P)+4*a1^2*x(P)^3+7*a1*b1*x(P)^2+(-2*a1*su*sv+6*a1*c1+b1^2)*x(P))*x(Q)^3+(y(P)^2+(-3*a1*x(P)^2-6*b1*x(P)+2*su*sv-2*c1)*y(P)+2*a1^2*x(P)^4+7*a1*b1*x(P)^3+(-4*a1*su*sv+4*a1*c1+6*b1^2)*x(P)^2+(8*b1*c1-4*b1*su*sv)*x(P))*x(Q)^2+(((2*su*sv-6*c1)*x(P)-b1*x(P)^2)*y(P)+a1*b1*x(P)^4+(-2*a1*su*sv+6*a1*c1+b1^2)*x(P)^3+(8*b1*c1-4*b1*su*sv)*x(P)^2+(8*c1^2-8*c1*su*sv)*x(P))*x(Q)

----- Expression du dénominateur de c21 avec su et sv

(x(Q)^2-2*x(P)*x(Q)+x(P)^2)*y(Q)-a1*x(Q)^4+(2*a1*x(P)-b1)*x(Q)^3+(y(P)-2*a1*x(P)^2+b1*x(P)+2*su*sv-2*c1)*x(Q)^2+
(-2*x(P)*y(P)+2*a1*x(P)^3+b1*x(P)^2+(4*c1-4*su*sv)*x(P))*x(Q)+x(P)^2*y(P)-a1*x(P)^4-b1*x(P)^3+(2*su*sv-2*c1)*x(P)^2

simplification denominateur c21 avec suv et factorisation

(x(Q)-x(P))^2*(y(Q)-a1*x(Q)^2-b1*x(Q)+y(P)-a1*x(P)^2-b1*x(P)+2*suv-2*c1)

ou encore

(x(Q)-x(P))^2*(y(Q)+y(P)-a1*(x(Q)^2+x(P)^2)-b1*(x(Q)+x(P))+2*suv-2*c1);

On pose DenC2b=y(Q)+y(P)-a1*(x(Q)^2+x(P)^2)-b1*(x(Q)+x(P))-2*c1

den c21 = DenA3B3*(2*suv+DenC2b)


----- Ecriture finale de c21 avec suv (=su*sv)
et la simplification du dénominateur
(numérateur pas encore factorisé)

(x(P)^2*y(Q)^2+((y(P)-3*a1*x(P)^2-b1*x(P))*x(Q)^2+(4*x(P)*y(P)-4*a1*x(P)^3-6*b1*x(P)^2+(2*suv-6*c1)*x(P))*x(Q)+x(P)^2*y(P)-a1*x(P)^4-b1*x(P)^3+(2*suv-2*c1)*x(P)^2)*y(Q)+(-a1*y(P)+2*a1^2*x(P)^2+a1*b1*x(P))*x(Q)^4+((-4*a1*x(P)-b1)*y(P)+4*a1^2*x(P)^3+7*a1*b1*x(P)^2+(-2*a1*suv+6*a1*c1+b1^2)*x(P))*x(Q)^3+(y(P)^2+(-3*a1*x(P)^2-6*b1*x(P)+2*suv-2*c1)*y(P)+2*a1^2*x(P)^4+7*a1*b1*x(P)^3+(-4*a1*suv+4*a1*c1+6*b1^2)*x(P)^2+(8*b1*c1-4*b1*suv)*x(P))*x(Q)^2+(((2*suv-6*c1)*x(P)-b1*x(P)^2)*y(P)+a1*b1*x(P)^4+(-2*a1*suv+6*a1*c1+b1^2)*x(P)^3+(8*b1*c1-4*b1*suv)*x(P)^2+(8*c1^2-8*c1*suv)*x(P))*x(Q))/(DenA3B3*(2*suv+DenC2b))

--- Solution 2 : réécriture de c22 avec su et sv

(-x(P)^2*y(Q)^2+sv*((2*x(P)*su*x(Q)+2*x(P)^2*su)*y(Q)-2*a1*x(P)*su*x(Q)^3+su*(2*y(P)-4*a1*x(P)^2-4*b1*x(P))*x(Q)^2+su*(2*x(P)*y(P)-2*a1*x(P)^3-4*b1*x(P)^2-8*c1*x(P))*x(Q))+((-y(P)+3*a1*x(P)^2+b1*x(P))*x(Q)^2+(-4*x(P)*y(P)+4*a1*x(P)^3+6*b1*x(P)^2+6*c1*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+2*c1*x(P)^2)*y(Q)+(a1*y(P)-2*a1^2*x(P)^2-a1*b1*x(P))*x(Q)^4+((4*a1*x(P)+b1)*y(P)-4*a1^2*x(P)^3-7*a1*b1*x(P)^2+(-6*a1*c1-b1^2)*x(P))*x(Q)^3+(-y(P)^2+(3*a1*x(P)^2+6*b1*x(P)+2*c1)*y(P)-2*a1^2*x(P)^4-7*a1*b1*x(P)^3+(-4*a1*c1-6*b1^2)*x(P)^2-8*b1*c1*x(P))*x(Q)^2+((b1*x(P)^2+6*c1*x(P))*y(P)-a1*b1*x(P)^4+(-6*a1*c1-b1^2)*x(P)^3-8*b1*c1*x(P)^2-8*c1^2*x(P))*x(Q))/((2*su*x(Q)^2-4*x(P)*su*x(Q)+2*x(P)^2*su)*sv+(-x(Q)^2+2*x(P)*x(Q)-x(P)^2)*y(Q)+a1*x(Q)^4+(b1-2*a1*x(P))*x(Q)^3+(-y(P)+2*a1*x(P)^2-b1*x(P)+2*c1)*x(Q)^2+(2*x(P)*y(P)-2*a1*x(P)^3-b1*x(P)^2-4*c1*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+2*c1*x(P)^2)

------ Den c22 avec suv

(-x(Q)^2+2*x(P)*x(Q)-x(P)^2)*y(Q)+a1*x(Q)^4+(b1-2*a1*x(P))*x(Q)^3+(-y(P)+2*a1*x(P)^2-b1*x(P)+2*suv+2*c1)*x(Q)^2+(2*x(P)*y(P)-2*a1*x(P)^3-b1*x(P)^2+(-4*suv-4*c1)*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+(2*suv+2*c1)*x(P)^2

--- Simplification du Den c22

(x(P)-x(Q))^2*(b1*(x(P)+x(Q))-(y(P)+y(Q))+2*suv+2*c1+a1*(x(P)^2+x(Q)^2))

den c22 = DenA3B3*(2*suv-DenC2b)

Expression finale de c22 avec suv

(-x(P)^2*y(Q)^2+((-y(P)+3*a1*x(P)^2+b1*x(P))*x(Q)^2+(-4*x(P)*y(P)+4*a1*x(P)^3+6*b1*x(P)^2+(2*suv+6*c1)*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+(2*suv+2*c1)*x(P)^2)*y(Q)+(a1*y(P)-2*a1^2*x(P)^2-a1*b1*x(P))*x(Q)^4+((4*a1*x(P)+b1)*y(P)-4*a1^2*x(P)^3-7*a1*b1*x(P)^2+(-2*a1*suv-6*a1*c1-b1^2)*x(P))*x(Q)^3+(-y(P)^2+(3*a1*x(P)^2+6*b1*x(P)+2*suv+2*c1)*y(P)-2*a1^2*x(P)^4-7*a1*b1*x(P)^3+(-4*a1*suv-4*a1*c1-6*b1^2)*x(P)^2+(-4*b1*suv-8*b1*c1)*x(P))*x(Q)^2+((b1*x(P)^2+(2*suv+6*c1)*x(P))*y(P)-a1*b1*x(P)^4+(-2*a1*suv-6*a1*c1-b1^2)*x(P)^3+(-4*b1*suv-8*b1*c1)*x(P)^2+(-8*c1*suv-8*c1^2)*x(P))*x(Q))/((-x(Q)^2+2*x(P)*x(Q)-x(P)^2)*y(Q)+a1*x(Q)^4+(b1-2*a1*x(P))*x(Q)^3+(-y(P)+2*a1*x(P)^2-b1*x(P)+2*suv+2*c1)*x(Q)^2+(2*x(P)*y(P)-2*a1*x(P)^3-b1*x(P)^2+(-4*suv-4*c1)*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+(2*suv+2*c1)*x(P)^2)

--- avec la simplification du dénominateur
(numérateur non encore simplifié)

(-x(P)^2*y(Q)^2+((-y(P)+3*a1*x(P)^2+b1*x(P))*x(Q)^2+(-4*x(P)*y(P)+4*a1*x(P)^3+6*b1*x(P)^2+(2*suv+6*c1)*x(P))*x(Q)-x(P)^2*y(P)+a1*x(P)^4+b1*x(P)^3+(2*suv+2*c1)*x(P)^2)*y(Q)+(a1*y(P)-2*a1^2*x(P)^2-a1*b1*x(P))*x(Q)^4+((4*a1*x(P)+b1)*y(P)-4*a1^2*x(P)^3-7*a1*b1*x(P)^2+(-2*a1*suv-6*a1*c1-b1^2)*x(P))*x(Q)^3+(-y(P)^2+(3*a1*x(P)^2+6*b1*x(P)+2*suv+2*c1)*y(P)-2*a1^2*x(P)^4-7*a1*b1*x(P)^3+(-4*a1*suv-4*a1*c1-6*b1^2)*x(P)^2+(-4*b1*suv-8*b1*c1)*x(P))*x(Q)^2+((b1*x(P)^2+(2*suv+6*c1)*x(P))*y(P)-a1*b1*x(P)^4+(-2*a1*suv-6*a1*c1-b1^2)*x(P)^3+(-4*b1*suv-8*b1*c1)*x(P)^2+(-8*c1*suv-8*c1^2)*x(P))*x(Q))/(DenA3B3*(2*suv-DenC2b))


La figure manipulable dans l’article

On notera l’écriture de la dérivée (la touche d du clavier maths est là pour ne pas changer de clavier sur tablette).

Dans la figure ci-dessous, penser à déplacer un des points des paraboles si elles ne sont pas dessinées à l’ouverture - peut dépendre du navigateur.


La figure en ligne, dans une fenêtre plus grande : http://goo.gl/jMRaB8


2.4.c. Les fonctions de C dans C

Juste mentionné pour la possibilité : comme le calcul sur les points, dont le produit, correspond à un produit de nombres complexes, que l’on dispose de la conjugaison, on peut construire des fonctions de C dans C. Ce serait tout un autre champ d’utilisation.

Voici un exemple de fonction du second degré à paramètres dans C.


Haut de la barre des expressions

Retour à l’interface

Aspects conditionnels

2.5. Traitement des aspects conditionnels des objets par les expressions

L’interface d’un inspecteur d’objet traitant de l’aspect conditionnel sophistiqué des objets, comme cela dans CaRMetal, n’a pas encore été réalisé. On peut néanmoins traiter des aspects conditionnels en les plaçant dans des « programmes JavaScript » sous forme d’expression.

Qu’est-ce qu’un « Programme JavaScript dans les expressions »

Beaucoup de choses sont possibles, on y consacrera le prochain onglet,
Pour ce qui nous intéresse ici on peut dire qu’il s’agit d’instructions JavaScript cohérentes, séparées par des point-virgules. La partie après le dernier point virgule est, en quelque sorte la partie externe, ce qui est renvoyé dans la figure.

En pratique, ce que l’on va faire ici c’est essentiellement cacher des objets selon certaines conditions, modifier leur opacité, leur taille, leur couleur etc.

2.5.a. Un premier exemple artificiel

Voici un exemple d’apprentissage proposé par Eric Hakenholz pour donner un rapide aperçu de toutes les possibilités (inutile de cliquer sur « le programme », se reporter à plus bas, sous la figure).


Et le code du « programme » est le suivant (c’est l’expression E2) :

A.setHidden(E1);Poly1.setHidden(E1);Poly1.setOpacity(E3);B.setOpacity(E3);Poly1.setRGBColor(r,g,b);S1.setPrecision(E5);A.setFontSize(E6);B.setShowName(E7);C.setxy(E8,C.gety());S1.setSize(E9);"cliquez-moi pour consulter le programme"

qui se traduit automatiquement dans le corps de la figure par cette ligne

E2=Expression("E2","","","","A.setHidden(E1);Poly1.setHidden(E1);Poly1.setOpacity(E3);B.setOpacity(E3);Poly1.setRGBColor(r,g,b);S1.setPrecision(E5);A.setFontSize(E6);B.setShowName(E7);C.setxy(E8,C.gety());S1.setSize(E9);\"cliquez-moi pour consulter le programme\"","-5.883245452198075","9.568961057788883");

Les deux derniers paramètres sont l’abscisse et l’ordonnée de la position de l’expression
En général on cache une telle expression de conditionnement, on peut même la super cacher en allant mettre un « h:2 » à la place du « h:1 » dans son STL (style).

On retiendra que l’on place une sorte de « nom de programme » à la fin, entre guillemets, tout ce qui précède relève d’un attribut d’objet, programmé « en objet » donc du style A.setHidden() etc ...
Les paramètres de ces attributs sont généralement d’autres expressions booléennes.

Bien entendu ici il y a de nombreux curseurs pour aller vite (comme pour les paraboles tangentes version élève) en pratique, c’est différent les conditions peuvent être plus ou moins sophistiquées.

Rappel de la correspondance avec les données de STL (le Style des objets)


Le code suivant est directement du code du logiciel

var STL = function(_n, _s) {
        var o = me.f(_n);
        _s = _s.split(";");
        for (var i = 0, len = _s.length; i < len; i++) {
            var e = _s[i].split(":");
            e[1] = me.p(e[1]);
            switch (e[0]) {
                case "c":// Color
                    o.setColor(e[1]);
                    break;
                case "h":// Hidden
                    o.setHidden(e[1]);
                    break;
                case "o":// Opacity
                    o.setOpacity(parseFloat(e[1]));
                    break;
                case "s":// Size
                    o.setSize(parseFloat(e[1]));
                    break;
                case "sn":// Show name
                    o.setShowName(e[1]);
                    break;
                case "f":// Font size
                    o.setFontSize(parseInt(e[1]));
                    break;
                case "l":// Layer
                    o.setLayer(parseInt(e[1]));
                    break;
                case "p":// Précision numérique
                    o.setPrecision(e[1]);
                    break;
                case "sp":// Forme des points
                    o.setShape(parseInt(e[1]));
                    break;
                case "i":// Incrément
                    o.setIncrement(parseFloat(e[1]));
                    break;
                case "sb":// Sur le contour d'un polygone
                    o.setOnBoundary(e[1]);
                    break;
                case "dh":// Pointillés
                    o.setDash(e[1]);
                    break;
                case "np":// Position du nom des objets
                    o.setNamePosition(e[1]);
                    break;
                case "tk":// Trace de l'objet
                    if (e[1]) {
                        setTimeout(function() {
                            me.Z.trackManager.add(o, true);
                        }, 1);
                    }
                    break;
                case "fl": // Objet flottant
                    if (e[1]) {
                        o.setFloat(true);
                        o.free = function() {
                            return false;
                        }
                    }
                    break;
                case "cPT": // Point d'un curseur d'expression
                    var stls = me.$U.base64_decode(e[1]);
                    STL(o.getcPTName(), stls);
                    break;
                case "cL": // Longueur d'un curseur
                    o.setCursorLength(parseInt(e[1]));
                    break;
                case "mg": // Magnétisme des objets
                    var t = eval("[" + e[1] + "]");
                    for (var k = 0; k < t.length; k++) {
                        t[k][0] = me.C.find(t[k][0]);
                    }
                    ;
                    o.setMagnets(t);
                    break;
            }
        }
    };

On notera que pour le moment (mars 2014)t, le magnétisme n’a pas été traité pour être manipulable par expression, de même que les paramètres des curseurs d’expression.

Dans le même ordre d’idée, on évitera de toucher au statut de point flottant par cette procédure.


2.5.b. Exemple du traitement de l’apparition des points dans l’exercice sur les cercles.

On reprend cet exercice du cercle logique à construire. Une première figure d’exploration avait 3 étapes, les milieux des côté et le centre du cercle circonscrit apparaissaient à partir de l’étape 2 et les angles seulement à l’étape 3.

Le code qui régit ceci est simplement cette expression :

I.setHidden(Etape==1);J.setHidden(Etape==1);K.setHidden(Etape==1);O.setHidden(Etape==1);aA.setHidden(Etape<3);aB.setHidden(Etape<3);aC.setHidden(Etape<3);"gérer les étapes"

ce qui donne une expression finale de ce type, dans le corps du texte du fichier. Les guillemets s’écrivent \" dans une chaine de caractères.

E4=Expression("E4","","","","I.setHidden(Etape==1);J.setHidden(Etape==1);K.setHidden(Etape==1);O.setHidden(Etape==1);aA.setHidden(Etape<3);aB.setHidden(Etape<3);aC.setHidden(Etape<3);\"g\u00e9rer les \u00e9tapes\"","-6.15","-2.85");

Les booléens des exprressions setHidden sont fonction de la position du curseur Étape.

En pratique on fait des copier coller, soit directement dans la figure, soit dans le fichier texte produit, à partir d’une première expression rentrée.

Rappel du copier-coller dans une figure
Il ne s’effectue que si le clavier math de DGPad est fermé, remplacé par le clavier standard sur tablette ou le clavier physique sur ordinateur.

2.5.c. Les aspects conditionnels dans la figure des patrons de cube

Il s’agit de celle proposée en figure d’introduction à cet article. Pour les lecteurs qui le souhaite, vous pouvez la télécharger depuis la figure selon le procédé indiqué dans la première partie de l’article.

Traitement des traces des faces au sol

E1=Expression("E1","","","","art1.setHidden(Enroule==0);art2.setHidden(Enroule==0);art3.setHidden(Enroule==0);art4.setHidden(Enroule==0);art5.setHidden(Enroule==0 || Patron==11);art6.setHidden(Enroule==0 || Patron==11);art7.setHidden(Enroule==0 || Patron>6);art8.setHidden(Enroule==0 || Patron>6);art9.setHidden(Enroule==0);art24.setHidden(Enroule==0 || Patron!=7);art25.setHidden(Enroule==0 || Patron!=7);art26.setHidden(Enroule==0 || Patron!=7);art13.setHidden(Enroule==0 || Patron>4);art14.setHidden(Enroule==0 || Patron>4);art15.setHidden(Enroule==0 || Patron>8 || Patron==7);art10.setHidden(Enroule==0 || (Patron>1 && Patron<7));art11.setHidden(Enroule==0 || (Patron>1 && Patron<7));art12.setHidden(Enroule==0 || Patron==3 || Patron==4 || Patron==6);art16.setHidden(Enroule==0 || Patron==1 || Patron==3 || Patron==4 || Patron==6);art17.setHidden(Enroule==0 || Patron==1 || Patron==4);art18.setHidden(Enroule==0 || !(Patron==3 || Patron==6));art19.setHidden(Enroule==0 || !(Patron==3 || Patron==4 || Patron==6));art20.setHidden(Enroule==0 || Patron!=4);art21.setHidden(Enroule==0 || Patron!=4);art22.setHidden(Enroule==0 || !(Patron==5 || Patron==6 || Patron==8));art23.setHidden(Enroule==0 || Patron<5 || Patron==7 || Patron==10);art27.setHidden(Enroule==0 || !(Patron==9 || Patron==11));art28.setHidden(Enroule==0 || Patron<9);art29.setHidden(Enroule==0 || Patron<10);art30.setHidden(Enroule==0 || Patron<10);\"cache segments sol\"","-21.87778019479119","-9.01750352325543");

On observe que toutes les arêtes au sol (artxx) sont cachées si Enroule=0 c’est-à-dire si le patron est déjà complètement déplié. C’est un joli effet, quand on bouge le curseur Enroule, sinon cela n’aurait pas été très esthétique car les arêtes se seraient superposées au patron. Ensuite elle sont cachée (avec un OU qui si note ||) selon les patrons où elle n’intervient pas. Par exemple :

art12.setHidden(Enroule==0 || Patron==3 || Patron==4 || Patron==6);

signifie que art12 est caché si Enroule=0 ou si on est sur les patrons d’indice 3, 4, 6 seulement, alors que dans l’extrait suivant

art19.setHidden(Enroule==0 || !(Patron==3 || Patron==4 || Patron==6));

C’est le contraire. Le segment art19 est caché si Enroule = 0 ou si les patrons NE SONT pas (le !) d’indice 3, 4 ou 6.

Traitement de la visibilité des faces du patron du cube

S’il y a 6 faces dans un cube, dans la gestion des rotations des faces les unes par rapport aux autres sur le patron, il y a en fait 15 faces à traiter car certaines sont reproduites deux ou trois fois selon leur axe de rotation. On pourrait faire autrement avec des faces booléennes mais ce serait plus complexe car les axes de rotation devraient eux aussi être booléens. Ici tout est simple, seule la gestion d’apparition est à traiter, et cela se fait simplement.

Le préfixe Pol signifie que c’est un polygone, en pratique une des faces du cube.

E4=Expression("E4","","","","Polav2.setHidden(Patron==11);Polgv2.setHidden(Patron!=4);Poldr1.setHidden(Patron>4);Polar1.setHidden(Patron>6);Polgr1.setHidden(Patron>1);Polfg.setHidden(Patron==1 || Patron==3 || Patron==4 || Patron==6);Polfd.setHidden(Patron<5 || Patron==7 || Patron>8);Polgv1.setHidden(!(Patron==3 || Patron==6));Poldv1.setHidden(!(Patron==9 || Patron==11));Polfgr1.setHidden(Patron<7);Polfgr2.setHidden(Patron!=7);Poldv2.setHidden(Patron!=10);Polfdr11.setHidden(Patron!=11);\"cacher les faces\"","-24.174258171851143","-7.94581380062745");

L’interprétation est maintenant évidente pour le lecteur, on ne détaille pas.

Voyons quelque chose d’un peu plus intéressant l’opacité des faces au fur et à mesure qu’on les plie.

2.5.d. Un cas numérique : traitement de l’opacité des faces

Toujours sur la même figure, c’est l’expression E5 (en ligne174 si on a un éditeur qui numérote les lignes)

E5=Expression("E5","","","","Poldr1.setOpacity(0.2+(1.6*Enroule/PI)*(aPdr1>0));Polar1.setOpacity(0.2+(1.6*Enroule/PI)*(aPar1<0));Poly2.setOpacity(0.2+(1.6*Enroule/PI)*(aPol2<0));Polav2.setOpacity(0.2+(1.6*Enroule/PI)*(aPav2<0));Polgv2.setOpacity(0.2+(1.6*Enroule/PI)*(aPgv2<0));Poly9.setOpacity(0.2+0.8*(aSol>0));Polgr1.setOpacity(0.2+(1.6*Enroule/PI)*(aPgr1>0));Polfg.setOpacity(0.2+(1.6*Enroule/PI)*(aPfg>0));Polgv1.setOpacity(0.2+(1.6*Enroule/PI)*(aPgv1>0));Polfd.setOpacity(0.2+(1.6*Enroule/PI)*(aPfd>0));Polfgr1.setOpacity(0.2+(1.6*Enroule/PI)*(aPfgr1>0));Polfgr2.setOpacity(0.2+(1.6*Enroule/PI)*(aPfgr2>0));Poldv1.setOpacity(0.2+(1.6*Enroule/PI)*(aPdv1>0));Poldv2.setOpacity(0.2+(1.6*Enroule/PI)*(aPdv2>0));Polfdr11.setOpacity(0.2+(1.6*Enroule/PI)*(aPdr11>0));\"Couleur des faces\"","-15.141444795415314","-8.40510939603944");

Là encore beaucoup de copier coller. Voyons le détail de ce qui se passe sur une face.

Polfg.setOpacity(0.2+(1.6*Enroule/PI)*(aPfg>0));

Pour chaque face il y a un angle, ici aPfg (pour angle de Polfg) qui va de -pi à pi et qui devient positif quand la face se retourne par rapport à l’utilisateur, c’est-à-dire quand on voit l’extérieur de la face. Alors l’enroulement est pris en compte dans l’opacité de la façon suivante : par défaut l’opacité (de l’intérieur des faces) est de 0.2 puis quand l’angle passe par 0, on ajoute un coefficient proportionnel à la fermeture, qui lui donnera la valeur 0.2 + 0.8, soit 1, quand le cube est fermé .

On notera quelques ratés dans la construction de l’angle car pour une dans partie il faut qu’il soit négatif et pour une autre partie il faut qu’il soit positif ... cela a été fait un peu vite.

Détermination de l’angle pour l’opacité


C’est plus simple que ce qu’on pourrait imaginer . L’angle qui va déterminer le retournement de la face est tout simplement l’angle (en 2D) du parallélogramme d’une face, donné par cette macro :

$macros["Angle2D_Points3D"]={
        name:"Angle2D_Points3D",
        parameters:["point","point","point"],
        exec:
        function (A,O,B){
Angle=Expression("a"+A+O+B,"","","","arg((B.coords2D()-O.coords2D())/(A.coords2D()-O.coords2D()))-PI","-10","-3");
STL(Angle,"c:#30614f;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
return [Angle];
}};

On notera qu’on peut forcer la lecture d’un point en coordonnées 2D, même si c’est un point 3D : c’est alors sa position à l’écran.

Le mélange des deux repères est aussi une des forces du logiciel, même si on ne détaillera pas beaucoup cet aspect dans cet article de présentation.


2.5.e. Exemples de traitements conditionnels imbriqués.

Dans le traitement de cette autre figure sur les trajets minimaux sur différents patrons : http://goo.gl/WuSD9X (à ouvrir dans une autre fenêtre) on est amené à traiter des couleurs des expressions (ligne 242 pour ceux qui ouvriraient la figure dans un éditeur de texte)

LesCouleurs=Expression("LesCouleurs","","","","if(d11==dmin) {d11.setRGBColor(255,0,0);} else {if (Pat==1) {d11.setRGBColor(36,159,38);} else {d11.setRGBColor(0,0,255);};};if(d12==dmin) {d12.setRGBColor(255,0,0);} else {if (Pat==4) {d12.setRGBColor(36,159,38);} else {d12.setRGBColor(124,101,21);};};if(d13==dmin) {d13.setRGBColor(255,0,0);} else {if (Pat==5) {d13.setRGBColor(36,159,38);} else {d13.setRGBColor(0,0,255);};};if(d21==dmin) {d21.setRGBColor(255,0,0);} else {if (Pat==6) {d21.setRGBColor(36,159,38);} else {d21.setRGBColor(0,0,255);};};if(d22==dmin) {d22.setRGBColor(255,0,0);} else {if (Pat==2) {d22.setRGBColor(36,159,38);} else {d22.setRGBColor(0,0,255);};};if(d23==dmin) {d23.setRGBColor(255,0,0);} else {if (Pat==7) {d23.setRGBColor(36,159,38);} else {d23.setRGBColor(0,0,255);};};if(d31==dmin) {d31.setRGBColor(255,0,0);} else {if (Pat==8) {d31.setRGBColor(36,159,38);} else {d31.setRGBColor(124,101,21);};};if(d32==dmin) {d32.setRGBColor(255,0,0);} else {if (Pat==9) {d32.setRGBColor(36,159,38);} else {d32.setRGBColor(124,101,21);};};if(d33==dmin) {d33.setRGBColor(255,0,0);} else {if (Pat==3) {d33.setRGBColor(36,159,38);} else {d33.setRGBColor(0,0,255);};}; \"couleurs des dij\"","-0.27777151931406957","-0.6350145044120702");

D’une manière générale on a un thème qui e répète :

"if(d11==dmin) {d11.setRGBColor(255,0,0);} else {if (Pat==1) {d11.setRGBColor(36,159,38);} else {d11.setRGBColor(0,0,255);};};

C’est-à-dire ; si d11 est la distance minimale mettre en rouge, sinon, si le patron est d’indice 1 (c’est celui de d11) mettre en vert, sinon mettre en bleu.

Le patron actif a donc sa longueur de trajet en vert, sauf s’il réalise la distance minimale et dans ce cas elle est affichée est en rouge. Dans tous les autres cas elle est en bleu.

On notera les  ; avant chaque allocade fermante.

On aurait certainement pu mettre des couleurs booléennes, avec des paramètres r,g, b, comme dans l’exemple initial, mais booléens bien entendu. Le traitement n’aurait pas été plus simple.

Utilisation des tests conditionnels JavaScript

On peut aussi utiliser les tests conditionnels plus ésotériques de JavaScript qui sont sous la forme

(test booléen) ?vrai:faux

On l’a déjà rencontré dans la figure sur le magnétisme, à propos de l’alignement de trois points. Revoyons plus précisément le code. Ce n’est pas simple à lire car ces tests conditionnels sont surtout indispensables dans le traitement d’un texte ... justement conditionnel. Avec l’écriture unicode des accents, cela peut devenir vite un peu illisible, on s’intéresse plus à la structure sous-jacente :

E11=Expression("E11","","","","var txt=\"Les points \"+M.getName()+\", \"+F.getName()+\" et \"+E.getName()+\" \";{{(abs(y((F-M)/(F-E)))<0.00000000001)?}}txt+\" sont align\u00e9s\":txt+\"{{ }} ne sont pas align\u00e9s\"","-11.525","4.2625");

L’expression est un programme au sens où elle commence par définir une variable txt qui vaut « Les points M, N et E ». Puis on poursuit par un test d’alignement : si les points sont alignés on affiche txt+« sont alignés », sinon txt+« ne sont pas alignés ».

Remarques essentielles
• Le test est entre parenthèses
• il n’y a aucun blanc dans ce type d’écriture de tests conditionnels, ni aprés les parenthèses du booléen, ni avant ou aprés les séparateurs ? et :.

Pour des tests imbriqués, on peut rester sur la version classique du if (test) condition vraie else condition fausse , la rigueur de la syntaxe est plus relachée.

2.5.f. Utilisation du traitement d’erreur

Avec les tests d’erreur, on aborde des situations plus sophistiquées, qui ne sont pas des situations élémentaires de classe, mais cela peut intéresser certains lecteurs, pour fignoler une modélisation par exemple.

L’instruction JavaScript utilisable ici est isNaN (Not a Number). La fonction isNaN renvoie vrai si l’argument n’est pas un nombre et faux si c’est un nombre. Pour tester l’existence d’un point on peut tester son abscisse.

Voici un exemple issu de la figure précédente sur les trajets minimaux selon les patrons. Il s’agit d’avertir l’utilisateur par une phrase à l’écran quand la configuration ne correspond pas au patron choisi. En effet parfois en déplaçant M ou N d’un pixel, on peut changer de statut à ce sujet.

Dans l’illustration suivante, on est sur le patron 8. En haut il y a un trajet de M à N avec le patron 8, en bas, on voit que le trajet au sol ne coupe pas la bonne arête, et on peux construire un point spécifique Pat8PasOK1 qui est équivalent (c’est pour cette équivalence que l’on crée de nouveaux points) à ce que la configuration n’est pas correcte pour un chemin avec ce patron.

JPEG

Selon les patrons (à 4 ou 5 faces) on aura une seule situation de ce type ou deux. On peut alors faire un traitement de cette façon (extrait du code de la figure, les lignes ne sont pas nécessairement consécutives dans la figure). Ce n’est peut-être pas le plus simple, c’est le premier qui me soit venu à l’esprit ...

Pat8PasOK1=OrderedIntersection("Pat8PasOK1",Sol31,AD,0);
Pat9PasOK1=OrderedIntersection("Pat9PasOK1",Sol32,EH,0);
Pat9PasOK2=OrderedIntersection("Pat9PasOK2",Sol32,AD,0);
PasPat8=Expression("PasPat8","","","","!isNaN(Pat8PasOK1.getX())","-1.1432871197740635","-3.815720762245937");
PasPat9=Expression("PasPat9","","","","!(isNaN(Pat9PasOK1.getX()) && isNaN(Pat9PasOK2.getX()))","-2.2865742395481266","-3.529898982302421");
NoConfig=Expression("NoConfig","Pas de configuration sur les faces dans ce contexte","","","(Pat==4 &&PasPat4==1) || (Pat==5 &&PasPat5==1) || (Pat==6 &&PasPat6==1) || (Pat==7 &&PasPat7==1) || (Pat==8 &&PasPat8==1) || (Pat==9 &&PasPat9==1)","-2.358029684534006","-3.3869880923306632");

Commentaire du code

L’existence de Pat8PasOK1 est équivalent au fait qu’il n’y a pas de patron. Donc le retour « false » de isNaN sur l’abscisse (2D bien évidemment) est équivalent au fait que ce n’est pas une bonne configuration et donc PasPat8 est la négation de isNaN sur ce point :
PasPat8 = !isNaN(Pat8PasOK1.getX()) (où le point d’exclamation est l’opérateur de négation)

Pour les patrons à 5 faces, il y a deux intersections d’arêtes possibles qui rendent compte que l’on n’est pas dans une bonne configuration. Il faut donc faire un petit peu plus de logique.
Pour le patron 9, la configuration n’est pas bonne, c’est-à-dire PasPat9 est vrai, si l’un des deux points Pat9PasOK1 ou Pat9PasOK2 existe, autrement dit si on n’a pas (not) l’inexistence (isNaN à vrai) des deux points (ET). D’où l’écriture :
PasPat9 : " !(isNaN(Pat9PasOK1.getX()) && isNaN(Pat9PasOK2.getX()))

Comme par construction il y a toujours des trajets sur les patrons 1, 2 et 3 - car ils n’ont que trois faces - aprés avoir traité ainsi les patrons 4 à 9, l’affichage de NoConfig en découle.

Haut de la barre des expressions

Retour à l’interface

Programmes

2.6. Premiers pas vers l’utilisation du JavaScript dans les expressions.

On a eu un premier exemple avec le traitement d’erreur, voyons maintenant des choses moins techniques, plus simples et plus concrètes.

2.6.a Exemple d’expressions plus complexes

Jusqu’ici les expression rencontrées étaient relativement simples. D’une manière générale, une expression peut être :
une expression algébrique (aspect calculatrice)
un curseur
la définition d’une fonction (dont la représentation graphique n’est qu’une option)
un tableau (dont les points 2D et3D, mis aussi un tableau de tableaux)
un programme
un texte
un mélange cohérent de ce qui précède (comme on l’a vu avec les textes conditionnels)

Voici par exemple un tableau de tableaux qui est à la fois un tableau de fonctions

PNG

Commentaires sur ces écritures

• On comprend bien les fonctions f et g issues de k.
• k(2) est un couple de couples donc un couple de deux points. L’icone de tracé apparaît dés que l’on tape k(2) comme expression.
On voit que l’on a donné le nom val_k2 à l’expression qui vaut k(2) et comme commentaire « k(2) = ». De même ce que l’on voit à côté des deux points créés, ce sont les expressions de ces points, quand on clique sur l’icone de calculatrice quand ils sont sélectionnés, leurs noms peuvent être autre chose (ici ils ne sont pas nommés).

2.6.b. Un premier programme avec des nombres.

Rappel de la règle d’or des programmes-expression

Le dernier point virgule est une séparation :
• ce qu’il y a avant est du JavaScript « pur », avec quelques simplifications (pas de Math.cos mais juste cos par exemple etc - utilisation du clavier math de DGPad).
• ce qu’il y a après le dernier point virgule est du DGPad et est dans DGPad, c’est la sortie.

Cela signifie qu’il n’y a aucune extension géométrique du JavaScript (comme Point, Line, Segment etc) dans les expressions programme. Mais, comme on va le voir plus loin, cela n’empêche pas de proposer des créations de listes de points.

La figure suivante est manipulable (curseur, changer le nombre 100 dans les eux expressions)

Voici un premier exemple de ce qui peut être fait numériquement.Remarquer que l’expression E2, dépendant de x, elle n’est correctement définie que si x intervient dans la sortie, d’’où le 0x+s.


2.6.c. Une subtilité sur le double appel des expressions.

Dans le cas où une expression calcule une fonction qui doit être appelée deux fois, on a deux cas de figure : un appel élémentaire où tout se passe comme attendu, et un appel d’un programme qui a ses propres variables. Dans ce cas on ne peux pas appeler directement deux fois ce même programme dans une seule expression. La distinction est subtile, et si un informaticien voulait bien prendre le temps d’expliquer ce qu’il se passe, je suis vivement intéressé.

Voici une situation dans laquelle j’ai rencontré ce problème, et comment y remédier. Là encore si le contexte mathématique ne vous parle pas, ce n’est pas essentiel, il ne sert que de support à expliquer la situation.

1. Le contexte mathématique

C’est une situation que je fais étudier régulièrement dans le cadre de l’apprentissage de Python pour travailler les fonctions et passer d’une écriture itérative à une écriture récursive. Ici on ne s’intéresse qu’à l’aspect itératif. Il y a à la fois un intérêt en programmation et en mathématique.

Théorème de condensation : un théorème sur l’accélération des suites à convergence lente.
Une suite réelle (u_n) converge vers \lambda. On suppose qu’elle admet un développement asymptotique (DA) de la forme :
u_n = \lambda + \frac{a}{n^\alpha} + O\left(\frac{1}{n^\bera}\right) avec a \neq 0 et 0 < \alpha < \beta
Alors v_n=\frac{2^\alpha u_{2n}-u_n}{2¨\alpha -1} converge vers \lambda et v_n - \lambda = O\left(\frac{1}{n^\bera}\right)

On notera qu’il faut connaître \alpha mais pas nécessairement le coefficient a.

Application à l’accélération de la convergence de la série des inverses des carrés

On sait que la suite u_n = \sum_{n=1}^{n} \frac{1}{k^2} converge vers frac{\pi^2}{6} et que la converge est lente.
On se propose d’accélérer la convergence en itérant plusieurs fois le principe de condensation. Pour cela on suppose acquis (tout bon livre d’exercice d’analyse) que la suite des sommes partielles admet un DA dans l’échelle des inverses des puissances, soit :
u_n = frac{\pi^2}{6} + \frac{a}{n} + \frac{b}{n^2}  + \frac{c}{n^3} + \frac{d}{n^4} + O\left(\frac{1}{n^5}\right)

Mise en oeuvre dans DGPad

On commence par calculer la caleur de n_n qu’on appelle SinvCar(n) - pour Somme des inverse des carrés.
Puis le premier niveau de condensation s’écrit simplement cds1(n) = SinvCar(2n)-SinvCar(n). Or c’est justement ce point - et ce point seulement qui pose problème et qui justifie ce paragraphe : parce que l’on appelle - semble-t-il - deux fois dans la même ligne une variable x dans la construction spécifique de SinvCar on ne peut écrire cds1 de cette façon.
Ensuite, il n’y aura pas de problème par les autres condensation.

Voici la figure, qui contient 6 itérations de la condensation, le code de SinvCar, et la simple façon de détourner la difficulté.


On notera la grande précision produite par ces itération : 12 décimales exactes pour cd6(5) et 10 pour cd5(5). On peut préciser les éléments calculés pour chacun :
Pour cds6(5) il faut calculer cds5(10) donc cds4(20), puis cds3(40) ... et donc SinvCar(320).
Autrement dit les 12 décimales exactes de la limite sont obtenues par des combinaisons linéaires des sept valeurs de u_{320}, u_{160}, u_{80}, u_{40}, u_{20}, u_{10} \; et \; u_5

En Python par exemple - ou en JavaScript mais pas dans une expression DGPad, on peut écrire une version récursive :

2.6.d. Un exemple de suite de points

L’interface permet de produire rapidement une liste de points, que la suite soit itérative ou récurrente.

Voici un exemple classique, déjà abordé en CarScript dans cet article (onglet Tournesol pour des références algorithmiques).

Le thème : le coeur de tournesol a été modélisé par une suite des points P_k d’affixe \sqrt{k}e^{k\theta}\theta est lié au nombre d’or : \theta = \frac{2\pi}{1+\Phi} soit environ 137,5¨. Pour cet valeur de l’angle, le nombre de spirales dans un sens et dans l’autre sont deux nombres consécutifs de Fibonacci (19 et 31 mais il faut vraiment les voir).

Pour le plaisir, on va ajouter un paramètre à l’angle ...

Tout d’abord la figure finale pour avoir un aperçu


Voici la façon dont cela se rédige dans les expressions-programme de DGPad :

var tab=[];for (var i=1;i<=500;i++){var u=0.2*sqrt(i);var k=i*ang*π/180; var v=[u*cos(k),u*sin(k)];tab.push(v);};tab

En pratique on construit le tableau de points sous forme de couples de deux nombres. Le tableau aprés le dernier point virgule est ce que l’expression renvoie à DGPad.

Alors l’interface construit la suite de ces tableaux de deux termes dans la fenêtre de DGPad et propose la création des points géométriques associés, comme ceci :

PNG

Ce qui surprend au début c’est que, tant qu’on ne sélectionne pas l’icone point, la construction de la liste de 500 termes est virtuelle, elle n’est pas dans le fichier d’exportation, qui est trés court : il ne contient que deux objets, le curseur et l’expression. Le voici :

// Coordinates System :
SetCoords(502.51498960212797,393.45617983785,59.02999218334108);
// Geometry :
ang=Expression("ang","","90","160","137.5","-6.988227074821539","6.157144298935235");
E1=Expression("E1","","","","var tab=[];for (var i=1;i<=500;i++){var u=0.2*sqrt(i);var k=i*ang*\u03C0/180; var v=[u*cos(k),u*sin(k)];tab.push(v);};tab","-8.174064941487474","4.971306432269301");
// Styles :
STL(ang,"c:#007c00;s:7;sn:true;f:18;p:4;cL:200;cPT:YzojMDA3YzAwO3M6MTA7ZjozMA==");
STL(E1,"c:#007c7c;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");

Manipulation en ligne pour la construction des points

La figure suivante (en ligne dans une nouvelle fenêtre) http://goo.gl/wCJG1X permet de faire la manipulation suivante (l’interface de SPIP est trop petite, elle ne permet pas d’atteindre l’icone de point) :

• Sélectionner la liste de points et choisir l’icone d’expression.
• Alors l’icone Point apparaît dans l’interface du module d’expression.
• La sélectionner pour créer les 500 points (cela peut prendre 10 ou 20 secondes)
• Puis manipuler ensuite le curseur comme ci-dessus

Le fichier de la figure passe des 4 Ko minimum à 27 Ko pour la création des 500 points et de leurs styles.

2.6.e. Avec une suite récurrente

Pour illustrer le propos, j’ai choisi une autre suite très célèbre, la suite logistique, avec ses bifffurcations (doublement des points attractifs quand un coefficient varie).

Techniquement, on étudie la suite définie par son premier terme u_0 et le terme u_{n+1}=ku_n(1-u_n)0<k \le 4. La suite converge pour k \le 3 puis a de plus en plus de valeurs d’adhérence quand k augmente (sous suites de limites différentes) jusqu’au chaos pour k=4.

Deux liens, parmi de nombreux sur la suite chaotique : celui de wikipedia et une analyse très profonde de Daniel Perrin (PDF de 69 pages)

Rappel de ce qu’il faut observer

PNG

Et dans l’illustration suivante, on remarquera le 3 cycle : on sait qu’ils sont attractifs aprés k=3,82

PNG


L’expression-programme

PNG

On remarque que tab est initialisé à un tableau contenant un point (associé à u_0)

Créer les points dans une figure en dehors du site SPIP : http://goo.gl/Cvdjwv

La figure finale dans l’article (avec les points).


Dans un cas comme dans l’autre explorer l’attraction des 3 cycles autour de 3,83 comme illustré dans le bloc précédent.

Comme on le voit sur ces exemples, ces expressions programmes sont centrées sur le JavaScript, et ne remplacent pas les scripts dont on a eu l’habitude avec CaRMetal où on peut mélanger JavaScript et son extension géométrique pour la création d’objets géométriques. La raison en est trés simple : les expressions sont constamment évaluées (on l’a vu avec le curseur sur la somme des nombres. Elles ne peuvent donc contenir de création d’objets géométriques, qui eux, ne doivent être créés qu’une seule fois. Il en résulte cette ’interface particulière des listes que l’on choisit de matérialiser ou non dans DGPad par une cione.

Haut de la barre des expressions

Retour à l’interface

Dichotomie

2.7. Dichotomie et angle

Dans cet exercice (hyper classique), on voit une expression-programme sur la dichotomie, et surtout on aborde une précision sur les angles, ce qui permettra de réaliser une expression d’une solution plus complexe que prévue pour mieux prendre en compte l’engagement direct vis à vis de l’utilisateur.

2.7.a. Le problème de la chèvre

On considère un champ circulaire de centre O de rayon 1 (OA=1), puis une corde d’extrémité A dont on cherche l’extrémité M pour qu’une chèvre, attachée en M, puisse brouter la moitié du champ circulaire.

Si on note x l’angle géométrique \widehat{MAO}, un calcul sur les aire aboutit à x_0 est solution quand 2x_0 (soit l’angle \widehat{NAM}) est solution de f(x)=0 avec f(x) = sin(x) -xcos(x) -\frac{\pi}{2}

2.7.b. Recherche de la solution

La fonction f est croissante sur [0,\pi] avec f(0)=-\frac{\pi}{2} <0 et f(\pi) =\frac{\pi}{2}-1 > 0 on peut donc chercher l’unique zéro de f sur cet intervalle, le seul qui nous intéresse, par dichotomie, ce qui, dans une expression programme de DGPad peut s’écrire ainsi :

on renvoie x_0=\frac‘{a+b}{4} dans DGPad et non pas \frac{a+b}{2} car la seconde valeur correspond à 2x_0, la solution de f(x)=0

L’angle solution étant trouvé, on se propose d’aimanter le point solution, sur le cercle trigonométrique, de part et d’autre de l’axe (OA), ce qui donne deux points M_1 et M_2 par lesquels le point M va ensuite être aimanté.

2.7.c. Calcul préliminaire de l’aire broutée

Si on note S_1 l’aire du secteur angulaire MAN du cercle de centre A passant par M, S_2 l’aire du secteur angulaire MON du cercle trigonométrique (de centre O passant par A), et MONA l’aire que quadrilatère MONA, l’aire broutée par la chèvre est simplement S_1+S_2-MONA ce qui sert d’ailleurs pour déterminer la fonction f et la solution x_0.

Dans un contexte dynamique, c’est-à-dire si on souhaite que M puisse prendre les deux positions solutions, en M_1 et M_2, c’est cette expression S_1+S_2-MONA qui est la plus délicate à exprimer, à cause de la subtilité de la mesure des angles dans DGPad.

2.7.d. Angle géométrique et angle algébrique

Quand on mesure des angles dans des figures, avec l’outil angle, on va au plus simple, les angles sont naturellement géométriques, et cela correspond très bien à ce dont on a besoin au collège.

Si on veut traiter des angles orientés, en général au lycée, on affiche alors leur mesures avec la calculatrice ce qui donne une expression en radian, algébrique, calculée, bien entendu, dans le sens trigonométrique.

L’illustration suivante décrit très bien la situation : l’angle \widehat{MAO} est un angle géométrique. Comme angle orienté, il est, à gauche, dans le sens trigonométrique, et donc l’angle affiché en radian lui correspond directement, alors qu’à droite, comme l’angle orienté est négatif, la mesure est donc la valeur de cet angle dans l’intervalle [0, 2\pi].

Ainsi quand M va être, sur le cercle, au dessus ou en dessous de la droite (OA), l’angle en radian va être soit positif soit négatif. Il en résulte une écriture booléenne de l’aire broutée en fonction de M - plus précisément en fonction de son ordonnée car la droite (OA) n’est rien d’autre que l’axe des abcisses. La variable appelée « aire verte » dans la figure ci-dessous est ainsi égale à :

(anglA*d(A,M)^2+(2*π-anglO))*(y(M)>0)+((2*π-anglA)*d(A,M)^2+anglO)*(y(M)<0)-MONA

2.7.e. Figure finale

Dans cette figue, compte tenu du code précédent, M est attiré par les deux solutions, symétriques par rapport à (OA). On notera une petite coquetterie : la précision de l’angle devient maximale quand on est sur la solution. Cela peut se faire ainsi :

// une première expression pour gdP (grande Précision)
gdP=(d(M,Msol)==0) || (d(M,Msol2)==0)
// Dans une autre expression, la précision de l'angle en A
if(gdP==0){anglA.setPrecision(4);} else {anglA.setPrecision(9);};"precision anglA"


Haut de la barre des expressions

Retour à l’interface

Un peu plus loin

2.8. Exemple d’une gestion plus complexe des points

Comme une expression est réévaluée en permanence (on l’a vu avec le premier exemple du curseur), elle ne peux pas contenir la création interne de points (qui pourraient être créés plusieurs fois, et donc le processus de création se fait après (icone point).

Cela signifie aussi que l’on ne peux avoir aucune référence à des points, directement dans une expression programme.

La subtiité de cet onglet est dans la compréhension du terme directement.

2.8.a. L’exemple du triangle de Sierpinsky comme attracteur

On veut essayer de construire le triangle de Sierpinsky comme attracteur d’une famille de contractions (ici il y a trois homothéties de rapport 1/2 donc se fait avec trois milieux tout simplement). On a déjà présenté cela de manière récursive avec CaRMetal (en ligne en java, mais tout est téléchargeable, pour les personnes intéressées cela mérite d’être regardé pour le ralentissement du processus ;-). Rappelons rapidement le principe :

Principe général du triangle de Sierpinsky comme attracteur

On considère un triangle ABC et un point initial P_0. On construit une suite P_n de points définie par P_{n+1}=h_{U,1/2}(P_n)U est aléatoirement un des trois point A, B ou C.

Écriture récursive des points (possible dans CaRMetal)
Le point est défini par lui-même. La récursivité fonctionne simplement car le point P est d’abord construit (ce qui l’initialisée en fait) puis ensuite ses coordonnées sont définies récursivement.
En particulier c’est moins simple pour les expressions (de CaRMetal) car elles ne sont pas prédéfinies (comme les points). L’initialisation se fait en ajoutant un bouton.

Dans l’article cité, l’écriture récursive de x(P) et y(P) utilise des tests conditionnels emboités :

x=if(rand==0,(x(P)+x(A))/2,if(rand==1,(x(P)+x(B))/2,(x(P)+x(C))/2))
y=if(rand==0,(y(P)+y(A))/2,if(rand==1,(y(P)+y(B))/2,(y(P)+y(C))/2))

Figure produite (dans l’article cité)

PNG

2.7.8. Un exemple de Sierpinsky sous DGPad qui n’aboutit pas

Pour mieux comprendre ce qu’il faut faire, il est intéressant de regarder aussi ce qui ne fonctionne pas :

A=Point("A",-2.775,2.175);
B=Point("B",-0.325,-2.45);
C=Point("C",-5.75,-2.875);
M=Point("M",-3.45,-1.425);
sommets=Expression("sommets","","","","[A,B,C]","-12.05","-4.6");
P1=Point("P1","sommets[0]","0");
P2=Point("P2","sommets[1]","0");
P3=Point("P3","sommets[2]","0");
E1=Expression("E1","","","","nuage=[M];for(n=1;n<=10;n++){d=floor(3*random());nuage.push((sommets[d]+nuage[n-1])*0.5)};nuage","-12.55","4.15");

• la variable nuage est initialisée à un point. Dès le départ, cela ne peut fonctionner.
• l’écriture récursive de nuage : valide en JavaScript mais pas encore réussi à l’utiliser dans une expression de DGPad ... car a priori appelle aussi l’initialisation. Néanmoins à creuser.
• le push d’un point construit comme milieu (même algébrique) de deux points ne peux pas non plus fonctionner.

On se dit, « Mais alors qu’est-ce qu’on peut faire ? ». La même chose, mais avec des liste !

En remplaçant chaque point par une liste et en faisant référence, non pas aux points, mais à leurs coordonnées, cela va fonctionner.

2.8.c. Version DGPad de Sierpinsky comme attracteur

A=Point("A",-2.775,2.175);
B=Point("B",-0.325,-2.45);
C=Point("C",-5.75,-2.875);
M=Point("M",-3.45,-1.425);
E1=Expression("E1","","","","var u=[M[0],M[1]]; var Sierp=[u];for(var n=1;n<=1000;n++){var ch=floor(3*random());var v= [A[0]*(ch==0)+B[0]*(ch==1)+C[0]*(ch==2),A[1]*(ch==0)+B[1]*(ch==1)+C[1]*(ch==2)]; var w=[(v[0]+u[0])/2,(v[1]+u[1])/2];Sierp.push(w);u=w};Sierp","-12.55","4.15");

• On commence par définir une variable u, couple de deux nombres à partir de M. 
• Le tableau de points Sierp est initialisé à cette variable.
ch est un nombre aléaoire qui prend les valeurs 0, 1 et 2.
v est un couple de deux nombres qui prennent les valeurs voulues par l’algorithme. On a choisi l’approche booléenne plutôt que conditionnelle pour des raisons d’efficacité.
• Précautionneux (mais probablement inutile), en fait c’est w qui rend compte de l’homothétie.
• On évite la récursivité par une simple itération (u=w).

Comme déjà mentionné, l’interface SPIP du site ne permet pas d’atteindre le boton icone « point ».

Pour créer les mille points de la liste dans une figure externe, si posssible dans un autre navigateur : www.dgpad.net/index.php.
Placer A, B, C et M quatre points.
Copier le code suivant :

var u=[M[0],M[1]]; var Sierp=[u];for(var n=1;n<=1000;n++){var ch=floor(3*random());var v= [A[0]*(ch==0)+B[0]*(ch==1)+C[0]*(ch==2),A[1]*(ch==0)+B[1]*(ch==1)+C[1]*(ch==2)]; var w=[(v[0]+u[0])/2,(v[1]+u[1])/2];Sierp.push(w);u=w};Sierp

Sélectionner l’outil expression, cliquer dans l’expression et avec l’icone clavier, cacher le clavier DGPad.
Coller alors l’expression.
• La liste se construit instantanément.
Cliquer alors sur l’icone Point.
• Attention il faut environ 30 s pour que les points se construisent.
Régler les questions d’apparence avec l’aspect des objets.

Voici la figure finale (avec 300 points pour une meilleure mobilité) : on peut déplacer le point initial M et parfois voir les premières itérations. On peut déplacer A, B, et C.


La version en ligne avec 1000 points déjà construits : http://goo.gl/QAXn9B

Remarque : la figure avec l’expression toute seule ne se charge pas quand on la glisse sur un navigateur sur ordinateur, comme si il y avait un bug dans l’expression, alors qu’il n’y en n’a pas. Il faut reconstruire la figure, d’où la procédure porposée plus haut.
Si quelqu’un pouvait avoir une explication à cela, je serais intéressé. Il est possible aussi que le code soit un peu limite ...

Le Code complet de la figure

// Coordinates System :
SetCoords(512,286,40);
// Geometry :
A=Point("A",-2.775,2.175);
B=Point("B",-0.325,-2.45);
C=Point("C",-5.75,-2.875);
M=Point("M",-3.45,-1.425);
E1=Expression("E1","","","","var u=[M[0],M[1]]; var Sierp=[u];for(var n=1;n<=1000;n++){var ch=floor(3*random());var v= [A[0]*(ch==0)+B[0]*(ch==1)+C[0]*(ch==2),A[1]*(ch==0)+B[1]*(ch==1)+C[1]*(ch==2)]; var w=[(v[0]+u[0])/2,(v[1]+u[1])/2];Sierp.push(w);u=w};Sierp","-12.55","4.15");
// Styles :
STL(A,"c:#0000b2;s:6;sn:true;f:30");
STL(B,"c:#0000b2;s:6;sn:true;f:30");
STL(C,"c:#0000b2;s:6;sn:true;f:30");
STL(M,"c:#131314;s:3.5;sn:true;f:30");
STL(E1,"c:#493239;s:7;f:24;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
SetCoordsStyle("isAxis:false;isGrid:true;isOx:true;isOy:true;isLockOx:false;isLockOy:false;centerZoom:false;color:#111111;fontSize:18;axisWidth:1;gridWidth:0.1");


Haut de la barre des expressions

Retour à l’interface


Certaines utilisations spécifiques des expressions n’ont pas été abordées, en particulier tout ce qui touche aux écritures formelles des points (2D ou 3D). On en parlera un peu dans la troisième partie. Pour une utilisation systématique de ces écritures formelles de points, se reporter à cet article de MathémaTICE déjà cité : Géométrie repérée 2.0 en 2D et 3D au lycée (février 2014).

3. Le module 3D

DGPad dispose d’un module 3D dans lequel les points sont effectivement des objets 3D et ce qui en découle est aussi en 3D. Ce n’est sans doute pas un logiciel de 3D au sens de Cabri 3D, mais d’un autre côté, DGPad a fait des choix d’interface d’une réelle simplicité d’usage qui permet à tout le monde de construire, très simplement, des figures 3D et de travailler la géométrie analytique en 3D.

Par exemple la figure d’introduction de cet article, sur les 11 patrons dynamiques du cube, ne nécessite que 170 lignes dans son code Geometry. C’est significatif quant à l’efficacité du module 3D. En fait c’est la richesse de son interaction naturelle avec les expressions qui rend son écriture aussi compacte.

Interface

3.1. L’interface 3D de DGPad : macros et icones

Le module 3D a été construit d’abord sur la base de macro-constructions : on pourrait croire que c’est juste un micro-monde spécifique de DGPad. Mais en réalité ce n’est pas le cas, car le logiciel a été modifié en profondeur pour que l’engagement direct s’applique même au mode de travail de l’utilisateur.

Pour donner un exemple concret, l’icone Cercle par trois points, appliqué dans une configuration 3D construit, en 3D, le cercle circonscrit à trois points (nous l’illustrerons plus loin).

3.1.a Les premières macros 3D

Pour entrer dans le mode 3D, il faut utiliser les macros 3D et commencer par créer un repère, en montrant l’origine du repère.

Les macros sont conçues actuellement en deux niveaux : un premier niveau générique, et un second de dossier, dont le principal est Géométrie

PNG

Repère 3D : la macro attend un point bien entendu.

Si une figure doit contenir une partie 2D et une partie 3D, il est important de créer le repère 3D en premier. En effet la partie 2D s’appuiera elle aussi sur un point flottant , simplement pour ne pas partir dans tous les sens quand le repère tourne. Or le système interne est conçu de telle manière qu’à la lecture d’un fichier, s’il y a de la 3D, l’origine du repère est le premier point flottant rencontré.

Un très bel exemple de mélange 2D et 3D de Monique Gironce de l’IREM de Toulouse. Elle utilise une approche plus aboutie que ce qui a été vu ici pour les transparences. On peut télécharger cette figure pour apprendre encore plus sur la gestion conditionnelle des aspects des objets (utilisation des calques).

On notera que les expressions ne suivent pas le repère 3D donc elles sont naturellement flottantes. C’est en particulier vrai pour les textes que l’on place avec les expressions.

Montrer le sol : permet de créer un carré quadrillé que l’on peut utiliser pour prendre rapidement des points sur le sol. Cela crée en même temps un curseur qui permet de montrer ou cacher le sol. S’utilise pour faire rapidement des figures en classe.

Gesture de la caresse : à ce sujet rappelons un point abordé rapidement dans les gestes possibles sur tablette c’est la caresse de l’écran. Elle permet plusieurs choses :
1. Prendre un point sur un objet. Il faut un peu d’habitude pour prendre un point sur un cercle et ne pas modifier la taille du cercle, mais on s’y fait très vite en fait,
2. Et plus particulièrement l’intersection de deux objets. Cet aspect a été beaucoup travaillé pour que la caresse puisse se prendre de loin.
3. Prendre un point dans un polygone ... et en particulier sur le sol ou une face d’un polyèdre. Se fait comme un point sur objet, une caresse rapide.

Restriction de Theta : limite l’angle interne pour la rotation de l’axe (Oz) : il est limité entre -pi/2 et pi/2 et donc ne peut pas faire un tour autour de O. Très pratique pour être sûr qu’on va éviter cet effet visuel que nous subissons tous au début, quand il n’y a pas d’arêtes cachés : l’illusion d’optique de Necker- en pratique on croit que (Oxyz) devient (Oyxz).

Arête 3D : trace un segment entre deux points en trait plein s’il doit être visible ou en pointillé sinon. La syntaxe est la même que sur CaRMetal : pour tracer une arête [AB] d’un polyèdre convexe, on montre U à droite - d’une autre arête [BU] du polyèdre - A, V à gauche - d’une arête [VA] et B. Sur des polyèdres complexes, il faut un peu d’entrainement. Voici ce que cela donne sur « le ballon de football » ... Ne pas shooter, juste faire tourner :


Point 3D : on utilise soit une expression déjà sur la figure (très pratique si on veut modifier une coordonnée plusieurs fois pour placer plusieurs points) soit on utilise une boite à dialogue. On peut entrer toute expression algébrique dépendant des variables de la figure (dont des curseurs).

3.1.b. Les macros du dossier « Géométrie 3D »

Ce sont les macros les plus importantes, les plus utiles.

Coordonnées 3D : renvoie, sous forme de liste à trois termes, les coordonnées 3D de tout point sur objet d’un objet 3D (segment, droite, cercle, polygone). Si M est un point et ExpM est cette expression, on peut récupérer ses coordonnées par ExpM[0], ExpM[1] et ExpM[2]. Souvent on peut simplement utiliser M[0], M[1] et M[2], mais pas toujours.

Distance 3D : s’applique à deux points. Renvoie une expression.

Normale : s’applique à un polygone en 3D. Construit un segment, en fait un vecteur normé, d’origine l’isobarycentre (donc construit aussi l’isobarycentre du polygone). Réalisée à partir d’un produit vectoriel, la normale est orientée selon le sens du polygone.

Perpendiculaire : s’applique à un polygone 3D et un point 3D.

Cercle par 3 points : comme son nom l’indique. En pratique on peut aussi utiliser l’icone du même nom dans la palette des icones de points.

Cercle par axe et point  : comme son nom l’indique : on se donne une droite 3D et un point 3D.

3.1.c. Les icones de point ou de droite

Elles n’ont pas toutes du sens pour la 3D, mais celles qui ont du sens sont fonctionnelles en 3D. Les icones suivantes ont donc un fonctionnement 2D et 3D.

• Segment,
• Droite,
• Demi-droite,
• Parallèle,
• Milieu,
• Symétrie centrale,
• Cercle par trois points,
• Polygone.

On comprendra que cette démarche préfigure un autre type d’engagement direct dans les logiciels logiciel 2D-3D de géométrie dynamique : il n’y a plus vraiment deux modes - d’autant qu’on peux mettre de la 2D et de la 3D ensemble : il y a une figure, avec des objets : le logciel reconnaît lui-même si l’utilisateur applique des outils à des objets en 2D ou 3D.

DGPad n’en est qu’à son début dans cette direction. À terme, la palette des points devrait non seulement s’appliquer comme actuellement, mais aussi s’adapter au mode 3D.

Un exemple d’utilisation élémentaire

Dans l’illustration suivante, après avoir crée le repère, on construit directement les points A, B et C à partir d’une expression..
On notera que de nombreuses écritures formelles (qui ne respectent pas l’écriture mathématique de Grassmann - mathématiquement la somme des coefs devrait être égale à 1 comme dans le cas de A - sont possible y compris des combinaisons linéaires de points.

PNG

Puis on a créé les trois plans et on choisit trois points M, N et P sur chacun de ces plans. L’illustration montre le cercle circonscrit en cours de construction à partir de l’icone appropriée appliquée en 3D.

On poursuit en prenant la perpendiculaire au centre du cercle circonscrit, et on peut faire vérifier le théorème de Pythagore dans l’espace par les élèves, en utilisant la macro distance présentée plus haut. Voici la figure :

Figure manipulable en ligne. Vous pouvez déplacer le trièdre, M, N , P E et R.


3.1.d. Analyse du code produit - fichier de la figure

Il est toujours instructif de lire de code produit par cette figure, en particulier ces quelques lignes

Y=Point("Y","[0,1,0]","1");
Z=Point("Z","[0,0,1]","1");
X=Point("X","[1,0,0]","1");
C=Point("C","X+Z","1");
B=Point("B","Y+Z","1");
A=Point("A","X+Y-O","0");
Poly3=Polygon("Poly3","_C,_X,_O,_Z");
Poly1=Polygon("Poly1","_O,_X,_A,_Y");
Poly2=Polygon("Poly2","_Z,_O,_Y,_B");
N=PointOn("N",Poly2,[0.395,0.285]);
P=PointOn("P",Poly3,[-0.216,0.529]);
M=PointOn("M",Poly1,[-0.287,0.639]);
Poly4=Polygon("Poly4","_M,_N,_P");
v=Expression("v","AB vect AC ","","","unitVector(crossProduct(M-N,P-N))","-1.438","-2.356");
C1=Circle3pts3D("C1",M,N,P);
R=PointOn("R",C1,1148);
U=Center("U",C1);
UR=Expression("UR","","","","d(E,R)","-1.36","-0.825");
UE=Expression("UE","","","","d(U,E)","-1.36","-0.589");


Point : on notera qu’il n’y a pas de « Point3D » par exemple. La fonction JavaScript (étende pour DGPad) Point accepte soit deux coordonnées, c’est un point 2D, soit une liste de trois termes c’est un point 3D. Mais elle peut accepter bien entendu aussi une expression algébrique (ici très simple) sur les points. Comme il faut que la fonction Point ait deux paramètres arbitrairement le deuxième paramètre est - généralement - 1 pour la 3D et 0 pour la 2D même si on voit que ce n’est pas vrai pour le point A.

Polygon : lui aussi semble ne pas faire la différence entre 2D et 3D, mais si on prend un point sur objet par PointOn, clairmeent le logiciel fait bien la différence.

Circle3pts3D : là on a une vraie différence entre la 2D et la 3D : la même icone redirige vers des procédures différentes puisque le logiciel doit tracer un cercle ou une ellipse en 3D. Par ailleurs, même si cela n’est pas utile de la savoir, en pratique le cercle 3D est un outil à part : pour le logiciel, ce n’est pas une ellipse, et le tracé est différent.

Distance : c’est bien la même fonction d qui est appelée et qui s’adapte, en interne à un calcul 2D ou 3D.

unitVector et CrosProduct sont des fonctions internes au logiciel, que l’on pourrait appeler directement dans des scripts par exemple.

On ne l’a pas fait ici pour ne pas alourdir la figure, mais si on prend une normale à un polygone, on obtient le code suivant :

Poly4=Polygon("Poly4","_M,_N,_P");
G=Point("G","Poly4.barycenter3D()","1");
D=Point("D","G+unitVector(crossProduct(M-N,M-P))","1");

On découvre donc la méthode barycenter3D des polygones quand ils sont en 3D et la compacitié de l’écriture du point D.

Haut de la barre du module 3D

Retour à la barre des expressions
Retour au début de l’article

Réalisation collège

3.2 Quelques réalisations simples pour le collège.

Dans cet onglet, on veut faire des figures rapidement, significatives, et pourtant très simples à construire. En voici deux exemples avec des commentaires de constructions. Bien entendu on pourrait aussi affiner les constructions avec les méthodes présentées dans l’onglet « aspects conditionnels ». On a choisi ici, au contraire d’aller au plus vite.

3.2.a Trois pyramides dans un cube

C’est un grand classique. Certains collègues font cela en 6° sur la base d’une construction en papier des pyramides, avec de belles réalisations. D’autres traitent la situation plus tard, selon de que l’on veut faire avec (du descriptif, du raisonnement, du calcul ...).

Voici une version dynamique parlante et l’analyse de sa construction :


Commentaires sur l’utilisation de la figure

• Le point A, sur la médiatrice de [XY] du repère (milieu et demi droite,) sert de zoom à la figure.
• Le fait de nommer les pyramides Par leurs sommets quand elles sont dans le cube aide à la résolution. On entend par là dire que la pyramide contenant le point M est la pyramide ABCDE, celle contenant le point N est BCGFE et celle contenant le point P est DCGHE.
• Ainsi les deux premières ont la face BCE en commun. En les plaçant dans le cube et en le faisant pivoter, on voit bien la partie non « remplie » par les pyramides est la pyramide DCGHE.

Preuve ou démonstration ?
Le terme « preuve » utilisé dans la figure l’est au sens de Balacheff. Rappelons de son vocabulaire :
Explication : discours visant à rendre intelligible le caractère de vérité, acquis pour le locuteur, d’une proposition ou d’un résultat.
Preuve : une explication acceptée par une communauté donnée (ici la classe) à un moment donné.
Démonstration : la forme de preuve de la communauté mathématique.
En particulier une démonstration peut ne pas être une preuve pour la communauté classe si elle n’est pas intelligible.

La construction du cube initial.
Par rapport à une construction physique, en papier, plus perceptive, cette approche invite à une réflexion et à une conceptualisation au sens où on dispose d’un cube préconstruit, et que l’on peut identifier chaque pyramide à une partie du cube initial.

Ce cube n’est pas construit avec la macro standard pour deux raisons : on n’a pas besoin de la gestion des pointillés (car on veut tout le cube en pointillé), et d’autre part la gestion des pointillés des arêtes nécessite la création de deux angles par arête donc 24 angles et 12 expressions qui ne nous seront pas utile. On a donc préféré faire une construction à la main dont voici de code :

// X et Y sont les points du repère
M1=MidPoint("M1",X,Y);
R1=Ray("R1",O,M1);
A=PointOn("A",R1,1.1839348860109955);
B=Point("B","[-A[0],A[1],0]","1");
C=Point("C","[-A[0],-A[1],0]","1");
E=Point("E","[A[0],A[1],2*A[0]]","1");
F=Point("F","[-A[0],A[1],2*A[0]]","1");
H=Point("H","[A[0],-A[1],2*A[0]]","1");
G=Point("G","[-A[0],-A[1],2*A[0]]","1");
D=Point("D","[A[0],-A[1],0]","1");

Efficacité dans la création des sommets : On crée une expression - celle du point B par exemple - en la validant par l’icone verte. Puis en la sélectionnant à nouveau on crée le point B et en la modifiant on crée ainsi tous les autres points du cube.

La pyramide de sommet M
On commence par créer géométriquement, par des symétriques, un segment dans le prolongement de [BC], de longueur 2BC, on place le point M sur ce segment, puis on construit, avec des expressions, les autres points de la pyramide, sur la simple base de paralélogrammes. Voici le code produit et son analyse.

Symc1=Symmetry("Symc1",B,C);
Symc2=Symmetry("Symc2",Symc1,B);
S14=Segment("S14",B,Symc2);
M=PointOn("M",S14,0.8753727867116252);
P1=Point("P1","M+C-B","1");
P2=Point("P2","M+A-B","1");
P3=Point("P3","M+E-B","1");
P4=Point("P4","M+D-B","1");

MP1P2P4 forment la base carrée de la pyramide et P3 est le sommet qui va aller sur E.
En pratique, une fois le point M placé sur le bon segment, il n’y a donc que 4 expressions à entrer, et construire les segments associés bien entendu.

Ergonomie fonctionnelle : Il est pratique de faire attention, dans le choix des faces, à ce qu’aucun des points M, N, P ne se retrouvent sur A, pour éviter de devir lever une ambiguité inutile pour les élèves.

Avis aux artistes : ceci étant fait, on peut améliorer la figure en coloriant les faces des pyramides de manière conditionnelle, selon des angles de vue (comme montré pour le cube) ou l’entrée dans la pyramide. Si quelqu’un s’amuse à finaliser cela, merci de transmettre vos productions qu’on puisse les ajouter à cet article (ou signaler où vous les avez déposéesr dans vos propres espaces de publication). Pour les personnes intéressées penser à regarder en détail le code de la figure de Monique Gironce, proposée dans la présentation initiale de l’item Repère 3D.

3.2.b. Pythagore dans l’espace

Parmi les nombreuses activités d’investigation et de conjecture que l’on peut proposer aux élèves pour faire utiliser le théorème de Pythagore dans l’espace, celle-ci est intéressante car la solution à trouver est simple.

Étant donné un cube, peut-on construire un carré plus grand que les faces du cube ayant ses sommets sur les arêtes du cube ?

Dans le cadre d’une tâche complexe ou d’une narration de recherche, on peut arrêter le texte ici. Dans le cadre d’une activité de classe plus dirigée - si on veut surtout travailler le calcul - on peut préciser une particularité du carré cherché : il a un côté dans une face, parallèle à une diagonale de la face.

PNG


Soit M un point de [AB], l’indication du côté dans la face (on choisit le sol) parallèle à une diagonale amène à construire Q sur [AE] tel que AM=EQ=x.

Dans une activité guidée, on peut commencer par chercher la nature générale d’un quadrilatère MNPQ avec N sur [CG] et P sur [GH] et demander par exemple
a) pourquoi le quadrilatère MNPQ coupe-t-il la face opposée en des points N et P tels que (NP) // (MQ) ?
b) et surtout pourquoi a-t-on CN=x et HP=x ? (Indication facultative : Thalès dans la face du haut par parallélisme à (HC).)
c) En déduire (par du calcul) que MNPQ est alors un rectangle.
d) déterminer x pour qu’il soit un carré.
e) quel est le rapport de son côté par rapport à l’arête du cube ?

La figure manipulable dans l’article
Selon le navigateur, déplacer un point pour que le cercle circonscrit soit correct.

Les coordonnées des différents points montrent que, d’une manière générale, M, N, P et Q sont à même distance du centre. Comme ils sont deux à deux symétriques par rapport au centre du cube, ils sont coplanaires et donc forment un rectangle.

Un problème de construction rencontré

Alors que j’ai réalisé des figures bien plus complexes sans problème, sur cette figure toute simple j’ai rencontré ce problème : M n’est pas reconnu comme point 3D. Cela pose un problème pour les différents calculs. On peut s’en sortir de cette façon :

PNG

Cette information est données pour aider les personnes qui peuvent la rencontrer, mais il est possible que ce bug surprenant soit résolu dans les semaines qui suivront la publication de cet article. Ce paragraphe sera alors supprimé (et la figure modifiée).

Exposé de 3° (maths en Jean 1995 sur le sujet) (PDF 6 pages rédigé par des collègiens qui répond aux dernières questions, mais de manière parfois confuse, il est préférable de refaire soi-même les calculs.)

Haut de la barre du module 3D

Retour à la barre des expressions
Retour au début de l’article

Géométrie analytique Lycée

3.3. Géométrie analytique dans l’espace pour le lycée

Il est trés simple de construire quelques macros efficaces pour le traitement des problèmes usuels dans l’espace : équations cartésiennes de plan, équations paramétriques de droites, distance d’un point à un plan etc ...

3.3.a Équation de plan.

On a déjà remarqué que le vecteur construit pour la normale est unitaire. En affichant ses coordonnées on a quasiment l’équation cartésienne du plan. Voici une illustration dynamique et comment construire concrètement (syntaxe) cette équation de plan.


Dans cette figure, on construit l’équation du plan ABC à partir de deux expressions ; les coordonnées du vecteur normal (V-G) et les coordonnées de G. On aurait tout aussi bien pu faire la macro à partir des deux points G et V.
Puis à partir d’un point M, on applique à nouveau la même macro, pour vérifier qu’à partir d’un point M mobile dans le plan, on obtient bien la même équation (le même terme constant).

Tester les macros en ligne sur cette figure (nouvelle page) : http://goo.gl/Npkvx5

Dans cette figure on a ajouté un point R sur une face du cube pour appliquer les différentes macros de la figure, dont la distance d’un point à un plan :

PNG

Détail de la construction de l’expression rendue par la macro.

PNG

Ce qui devient dans le code du fichier (le guillemet se code \")

// La macro associée à la construction précédente
$macros["EqPlanparExpnp"]={
        name:"Eq Plan par Exp n p",
        parameters:["expression","expression"],
        exec:
        function (n,p){
E1=Expression("E1","ABC :","","","n[0]+\"x + (\"+n[1]+\")y + (\"+n[2]+\")z = \"+(n[0]*p[0]+n[1]*p[1]+n[2]*p[2])","-2.6","-0.6");
STL(E1,"c:#07371e;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
return [E1];
}};

Cette macro peut être reprise pour avoir un seul objet initial : le polygone qui définit le plan. On remarquera que la macro fonctionne avec n’importe quel polygone puisque qu’elle prend les trois premiers points du polygone. Ainsi que l’on ait un triangle, un quadrilétère, un pentagone ou encore un hexagone, la macro fonctionne.

$macros["EqplanparPoly"]={
        name:"Eq plan par Poly",
        parameters:["area"],
        exec:
        function (Poly1){
P3=DefinitionPoint("P3",Poly1,2);
P2=DefinitionPoint("P2",Poly1,0);
P4=DefinitionPoint("P4",Poly1,1);
P21=Point("P21","Poly1.barycenter3D()","0");
p=Expression("p","","","","P21","0.8","-4.2");
P31=Point("P31","P21+unitVector(crossProduct(P2-P4,P2-P3))","0");
n=Expression("n","","","","P31-P21","-2.7","-4.2");
E1=Expression("E1","ABC :","","","n[0]+\"x + (\"+n[1]+\")y + (\"+n[2]+\")z = \"+(n[0]*p[0]+n[1]*p[1]+n[2]*p[2])","-2.6","-0.6");
STL(E1,"c:#07371e;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
return [E1];
}};

3.3.b. Équations paramétriques de droites

On peut poursuivre la même chose, en plaçant les trois relations des équations paramétriques sous la forme [x(t), y(t), z(t)]. La figure suivante contient la macro associée à l’équation paramétrique d’une droite en donnant deux points de la droite


Utilisation de la figure
a) On peut utiliser la fonction f1, par exemple vérifier que f1(1) est le point R, ou placer d’autres points.
b) on peut prendre un point sur la droite (MR) et vérifier que l’équation est bien proportionnelle.
c) afficher d’autres équations de droite
(pour b) et c) penser à déplacer la première équation de droite).

Pour manipuler plus simplement les expressions, vous pouvez utiliser cette figure (ouvrir dans une nouvelle fenêtre) : http://goo.gl/aqRD5y

Voici le code de la macro. On remarquera qu’on a utilisé CdR et CdM, les expressions associées aux points M et R, plutôt que directement les points M et R, car c’est plus stable.

$macros["Equationdedroite"]={
        name:"Equation de droite",
        parameters:["point","point"],
        exec:
        function (M,R){
CdR=Expression("CdR","","","","R","-4.241584599414012","-3.994466192317718");
CdM=Expression("CdM","","","","M","-4.241584599414012","-4.289532947059563");
E1=Expression("E1","Equation (MR) = ","","","\"[\"+CdM[0]+\"+(\"+(CdR[0]-CdM[0])+\")*t,\"+CdM[1]+\"+(\"+(CdR[1]-CdM[1])+\")*t,\"+CdM[2]+\"+(\"+(CdR[2]-CdM[2])+\")*t]\"","-4.610418042841318","-0.5274318241010468");
STL(E1,"c:#b40000;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjoxNw==");
return [E1];
}};

Amélioration possible : on pourrait mettre un M.coords3D() et un R.coords3D() à la place de M et R pour définir CdR et CdM. Cela n’a pas été utilie ici.

Beaucoup d’autres options sont possibles pour construire des équations paramétriques de droites, nous ne donnons ici qu’un exemple de solution.

Haut de la barre du module 3D

Retour à la barre des expressions
Retour au début de l’article

Un autre exercice dans l’espace

3.4. Un exemple d’exercice élémentaire dans l’espace.

Exercice de l’ancien « Terracher rouge » de TC (cela remonte à quelques années donc).

Dans cette figure, A sert de zoom. Un bon exercice - sinon pour des élèves au moins en formation, est la construction de la figure. Pour une utilisation en classe on supprimera le bouton de solution.


Amélioration facilement ensivageable : gestions des arêtes en pointillé.

Haut de la barre du module 3D

Retour à la barre des expressions
Retour au début de l’article

Espace Fun

3.5. Exemples de géométrie pseudosphérique

La pseudosphère est un peu (d’où le « pseudo » plutôt que l’anti - ce sont les termes de Beltrami lui-même) comme la sphère : quand la sphère est une surface dont la courbure (de Gauss) est constante et vaut R^2 si R est le rayon de la sphère, alors la pseudosphère est une surface de courbure constante \frac{-1}{R^2}. Elle a un génératrice facile à construire.

Beltrami est le premier à s’être aperçu que la géométrie intrinsèque de la pseudosphère est hyperbolique. La pseudosphère ne représente néanmoins qu’un partie du plan hyperbolique. Beltrami a cherché pendant des années une surface qui représenterait tout le plan hyperbolique. Il est décédé en 1900 et donc n’a pas connu le théorème de Klein, démontré en 1901 qui montre que ce n’est pas possible.

Dans les deux figures suivantes, les points A, B, C sont manipulables par les points du même nom (pour leur longitude) et par u_A (non visible sur la figure à l’ouverture), u_B et u_C pour leur altitude.

Sur ordinateur : on peut déplacer aussi le trièdre (clic-droit glisser)
Sur tablette : ne pas tenter de déplacer le trièdre ... ces figures sont dans les limites d’une utilisation sur tablette.

3.5.a. Médiatrices et cercle circonscrit à un triangle


3.5.b. Hauteurs d’un triangle pseudosphérique



Contrairement à ce qu’on pourrait croire ici, en géométrie hyperboliques, les médiatrices ne sont pas nécessairement concourantes, et les hauteurs non plus ... Mais elles ont d’autres propriétés.

Les figures sont dans le dossier de téléchargement en fin d’article. Les curieux pourront regarder les macros utilisées et la densité de ces macros, où tout est géré par des listes, il y a quelques exemples dans le bloc suivant : ces figures sont aussi là pour illustrer l’efficacité de la démarche retenue par ce logiciel pour la 3D ...

Quelques macros de cette figure


$macros["ConstDroiteck2"]={
        name:"Const. Droite [c,k2]",
        parameters:["expression","expression"],
        exec:
        function (CdA,CdB){
CstGene=Expression("CstGene","Const2pts = ","","","[((exp(CdA[0])+exp(-CdA[0]))^2/4-(exp(CdB[0])+exp(-CdB[0]))^2/4+CdA[1]^2-CdB[1]^2)/(2*(CdB[1]-CdA[1])),(exp(CdA[0])+exp(-CdA[0]))^2/4+(CdA[1]+((exp(CdA[0])+exp(-CdA[0]))^2/4-(exp(CdB[0])+exp(-CdB[0]))^2/4+CdA[1]^2-CdB[1]^2)/(2*(CdB[1]-CdA[1])))^2]","1.5","-0.4");
STL(CstGene,"c:#2f542d;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
return [CstGene];
}};
$macros["droiteparConst"]={
        name:"droite par Const",
        parameters:["expression"],
        exec:
        function (CstAB){
PmaxDrte=Point("PmaxDrte","[-CstAB[0]+sqrt(CstAB[1]-1),-1]","0");
PminDrte=Point("PminDrte","[-CstAB[0]-sqrt(CstAB[1]-1),-1]","0");
SegDrte=Segment("SegDrte",PminDrte,PmaxDrte);
tetaK=PointOn("tetaK",SegDrte,0.8);
chuK=Expression("chuK","chuK = ","","","sqrt(CstAB[1]-(x(tetaK)+CstAB[0])^2)","2","-0.7");
uK=Expression("uK","uK = ","","","log(chuK+sqrt(chuK^2-1))","2.","-0.5");
PtDrt=Point("PtDrt","[cos(x(tetaK))/chuK,sin(x(tetaK))/chuK,uK-(exp(uK)-exp(-uK))/(exp(uK)+exp(-uK))]","0");
LaDroite=Locus("LaDroite",PtDrt,tetaK);
STL(LaDroite,"c:#b40000;s:3;f:30;p:0");
return [LaDroite];
}};
$macros["CoordInter2droites"]={
        name:"Coord Inter 2 droites",
        parameters:["expression","expression"],
        exec:
        function (CstDrt1,CstDrt2){
CdInter=Expression("CdInter","CoordInter = ","","","[log(sqrt(CstDrt1[1]-(((CstDrt1[1]-CstDrt2[1])/(CstDrt1[0]-CstDrt2[0])-CstDrt1[0]-CstDrt2[0])/2+CstDrt1[0])^2)+sqrt(CstDrt1[1]-(((CstDrt1[1]-CstDrt2[1])/(CstDrt1[0]-CstDrt2[0])-CstDrt1[0]-CstDrt2[0])/2+CstDrt1[0])^2-1)),((CstDrt1[1]-CstDrt2[1])/(CstDrt1[0]-CstDrt2[0])-CstDrt1[0]-CstDrt2[0])/2]","2.3","-0.9");
STL(CdInter,"c:#512475;s:7;f:18;p:4;cL:200;cPT:YzojNzgwMDEzO3M6MTA7ZjozMA==");
return [CdInter];
}};
$macros["PointparCoord"]={
        name:"Point par Coord",
        parameters:["expression"],
        exec:
        function (CdM){
LePt=Point("LePt","[2*cos(CdM[1])/(exp(CdM[0])+exp(-CdM[0])),2*sin(CdM[1])/(exp(CdM[0])+exp(-CdM[0])),CdM[0]-(exp(CdM[0])-exp(-CdM[0]))/(exp(CdM[0])+exp(-CdM[0]))]","0");
STL(LePt,"c:#0000b2;s:6;f:18");
return [LePt];
}};


3.5.c. Cercles exinscrits sur la pseudosphère avec DGPad

Proposé ici seulement dans une nouvelle fenêtre (uniquement pour ordinateur, Chrome ou Safari fortement conseillés comme navigateur) : http://goo.gl/jifNcg

3.5.d. Version antérieure avec points mutlifeuilles

Pour avoir fait de nombreuses figures sur la pseudosphère avec Cabri (2003), CaRMetal (2008) et DGPad (2013), je peux dire que l’efficacité la plus grande est celle de DGPad, même si la version CaRMetal est, pour le moment, mathématiquement plus intéressante car CaRMetal permet l’enroulement des points sur la pseudosphère en manipulation directe (on peut faire plusieurs tours à A, B ou C) ce qui n’est pas encore implémenté dans DGPad :

PNG

Explications et nombreuses figures sous CaRMetal (en java). Dossier CaRMetal téléchargeable à la fin de cet article.

Haut de la barre du module 3D

Retour à la barre des expressions
Retour au début de l’article


Complément à la partie Espace

Cette autre prise en main de l’espace de DGPad propose en particulier d’autres figures 3D intéressantes (dont plusieurs utilisées en Licence de maths)

Plusieurs activités possibles autour du parcours minimal entre deux points de deux deux faces opposées d’une boite ouverte (un tiroir) et la recherche de trajets de même longueur selon des patrons différents (selon des parcours de faces différents). 19 figures en ligne, dans l’article ou à l’extérieur, dont certaines à compléter avec des expressions données dans l’article.

4. Téléchargement et liens divers

Compléments divers et téléchargement de toutes les figures de l’article.

4.1. La webApp et les iApp DGPad

Dans cet article on a privilégié DGPad comme webApp, c’est-à-dire une utilisation dans un navigateur. Préférer Chrome ou Safari pour les figures complexes ou la 3D : Firefox est deux fois moins rapide que les deux autres pour le JavaScript dynamique.

DGPad est aussi une iApp pour tablettes

DGPad pour Androïd - DGPad pour iOS

L’intérêt de l’application sur tablette est qu’on peut être totalement autonome, sans utilisation d’une connexion internet : vous pouvez transférer le dossier des figures de cet article - entre autre - sur votre tablette (dans un dossier DropBox présent sur votre tablette par exemple).
Alors tout fichier peut directement s’ouvrir dans l’application DGPad.

DGPad et Android à la Réunion

Il y a un soucis avec certaines tablettes, dont celles de la Région pour l’expérimentation en lycée : elle ne trouvent pas DGPad (alors qu’une tablette Sanmsung dans la même salle trouve l’application). Selon la machine, le Store dit « vous n’avez pas d’appareil » ou encore « cette application n’est pas disponible dans votre pays ». Pourtant on sait que le GooglePlay est - théoriquement - totalement disponible à la Réunion depuis janvier 2014.

4.2. Vidéos d’apprentissage de DGPad

Le site de DGPad contient de nombreuses vidéos de l’auteur commentant le fonctionnement du logiciel.

Sur le site de l’IREM de La Réunion, David Ethève, enseignant en Lycée Professionnel à Saint Joseph propose aussi des vidéos d’apprentissage dans deux articles sur des activités pour ses élèves de seconde :
article 1 : présentation de DGPad pour les élèves (géométrie, tracé de courbes)
article 2 : Agrandissement/Réduction en seconde.

Vidéos sur les expressions

Une première vidéo de 15 min, par l’auteur du logiciel, présentant les premières fonctionnalité

Une deuxième vidéo, sur la programmation dans les expressions (7 min), résevée, selon l’auteur, aux « power users ».

4.3. Autres ressources

Les scripts
On n’a pas parlé de scripts dans cet article. Ce sont des programmes partiellement écrits à la main car incorportant du JavaScript et des objets de DGPad. Il n’y a pas encore d’interface (comme dans CaRMetal) on travaille donc partiellement dans le logiciel et partiellement sur les fichiers.

Des scripts géométriques ont été proposés dans cet article de MathémaTICE à l’époque où les expressions n’étaient pas implémentées (et DGPad était seulement une webApp). Depuis, avec les expressions on peut faire les mêmes choses très différemment.

Une figure de l’auteur du logiciel
Les 8 cercles d’Apollonius - avec comportement totalement dynamique.

Ressources sur MathémaTICE

Deux ressources 3D sur le site de MathémaTICE ont déjà été mentionnées à la fin de la partie Espace..

Le site de l’IREM de La Réunion ayant disparu des radars du web pendant environ 3 mois (mi novembre à fin février) Alain Busser a régulièrement écrit dans MathémaTICE, y compris pour GeoGebra, avec des illustrations DGPad.

En cours de rédaction
Dans le numéro 40 de MathémaTICE, cet article parle(ra) des expressions avec d’autres exemples, d’autres points de vue éventuellement, et de nouvelles vidéos de Monique Gironce, sur des figures de Alain Busser.

L’IREM de Toulouse prépare aussi un dossier en ligne sur DGPad avec vidéos et figures en ligne.


Documents joints

DGPAD_IREM_RUN_721v1
DGPAD_IREM_RUN_721v1
Les figures de l’article (47). Version 1 du 18 mars 2014

Commentaires

Annonces

Prochains rendez-vous de l’IREM

Séminaire EDIM-IREM

- Mercredi 14 juin 2017, 14h-18h, PTU, Saint-Denis, salle S23.6
- Mercredi 21 juin 2017, 14h-18h, 146 route de Grand-Coude, Saint-Joseph


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 24 juillet 2017

Publication

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

Visites

5 aujourd'hui
427 hier
2064385 depuis le début
8 visiteurs actuellement connectés