IREMI de la Réunion

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.

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.

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.

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.

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.

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).

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 :

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.

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 ...

(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)

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.

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.

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 :

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.

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.

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.

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 :

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

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.

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.

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).

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 :

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.

• É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 :

• É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.

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.

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 :

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.

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.

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.

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.

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 :

• 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 ;-)

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é.

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 » :

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.

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)

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.

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 :

• 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.

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

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.

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)

Caractérisation de ABC équilatéral

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

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)

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.

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.

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.

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)

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.

Voir la résolution par cette méthode.

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.

Détail du calcul dans DGPad

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)

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.