Présentation rapide de DGPad (en vidéo)
Evolutions
CaRMetal 4.3
5 janvier 2019
Dans cette version de CaRMetal, on s'est attaché aux figures dans le disque de Poincaré (en géométrie non euclidienne hyperbolique), et en particulier on a implémenté une tortue dynamique dans cet espace.
- Le rayon par défaut du disque de Poincaré a été fixé à 1 (auparavant il était égal à 4).
- La distance hyperbolique a été ajustée.
- De nouvelles CaRCommandes pour la tortue hyperbolique sont apparues :
- AvancerDP().
Cette CaRCommande s'utilise comme Avancer(), mais renvoie un tableau JS de type ["P1,P2,...,P10","c1"] alors que Avancer() renvoie un tableau JS de type ["P1","s1"]. - ViserDP()
- AvancerDP().
- On a ajouté un opérateur distDP(,) sur les expressions (qui s'utilise comme d(,) en géométrie euclidienne)
Des exemples d'application sont donnés dans cet article MathémaTICE.
CaRMetal 4.2.9
9 décembre 2018
- Amélioration du comportement de l'éditeur en mode pseudo-code : il s'agit en particulier de la traduction automatique en direct du signe de la multiplication (* en \(\times\) et réciproquement).
Dans la version 4.2.8, le signe * était automatiquement transformé en \(\times\) dans les passages qui n'étaient pas entre guillemets. Ce comportement pouvait poser problème en phase de rédaction, certains passages par nature entre guillemets pouvant temporairement apparaître en dehors des guillemets et subir la transformation. Or, quand on a une multiplication en programmation dynamique (= dans une expression entre guillemets) le signe \(\times\) ne fonctionne pas, il faut impérativement utiliser le signe *.
Dans la version 4.2.9, on a ajouté un comportement : le signe \(\times\) est automatiquement transformé en * dans les passages entre guillemets. Cela permet d'avoir toujours le bon symbole. - Correction d'un bug de l'interpréteur en mode pseudo-code : les fonctions trigonométriques inverses étaient mal interprétées (comme on pouvait le voir avec la CaRCommande getRealScript).
- Ajout de la CaRCommande AutoriserRentrant (doublon de AngleRentrant qui exprime plus clairement que cette CaRCommande s'applique aussi à des arcs).
CaRMetal 4.2.7
14 décembre 2017
Finalisation du mode pseudo-code pour mieux prendre en compte les scripts comportant une erreur.
En particulier, on a traité un bug d'affichage des messages d'erreurs (ce n'était pas toujours la ligne fautive qui était mise en gras).
Par effet collatéral (positif), la CaRCommande getRealScript() se trouve améliorée.
CaRMetal 4.2.6
Finalisation du mode pseudo-code.
En particulier, on a traité les guillemets, la traduction des valeurs de vérité et la traduction des éléments manquant.
Ce qui permet d'écrire ce petit programme bien innocent (et d'obtenir exactement le résultat attendu).
Tables de multiplication :
Remarque : on peut ajouter des "fin pour" si on le souhaite, cela ne perturbera pas le script.
Cela permet aussi de peaufiner le script du dahlia par exemple (les scripts peuvent être écrits entièrement en français) :
CaRMetal 4.2.5
Mode pseudo-code :
- Correction d'un bug en mode pseudo-code avec les CaRCommandes tortue Avancer et Reculer .
- l'opérateur "modulo" est reconnu (identique à %).
Général :
- Ajout des CaRCommandes EntréeNombreEntier et EntréeNombreDécimal qui évitent de caster le résultat donné en entrée (a priori une chaîne de caractères).
CaRMetal 4.2.4
Les nouveautés de cette versions sont :
- la résolution d'un bug de l'interface en mode pseudo-code;
- l'amélioration de cette interface avec transformation dynamique des tabulations en 3 espaces;
- l'apparition de nouvelles CaRCommandes destinées à la 3D (superposition des calques).
Un bug concernant l'interface en pseudo-code a été résolu. Ce bug faisait planter l'interface dans certains circonstances.
Il est désormais possible d'écrire des commentaires.
La tabulation est remplacée dynamiquement par trois espaces d'indentation. Cela rend l'écriture plus agréable et limite les erreurs par copier-coller.
On a créé de nouvelles CaRCommandes pour la 3D :
- Triangle3D
- Quadrilatère3D (Quadrangle3D en anglais)
- Polygone3D (Polygon3D en anglais)
Ces CaRCommandes permettent de fixer automatiquement le numéro de calque d'un polygone en fonction de la position de son barycentre.
On a aussi traduit la CaRCommande SetIconSelection en français sous le nom plus évocateur de ClicVirtuel.
CaRMetal 4.2.3
Les nouveautés de cette versions sont :
- l'amélioration des CaRCommandes CercleRayon et AngleFixe;
- la prise en compte de la boucle répéter n fois;
- le mode pseudo-code.
L'article donne de nombreux exemples d'application.
Toutes les figures avec les scripts sont données en pièces-jointes (NB : pour les motifs, c'est dans le même classeur CaRMetal, avec sélection par onglets).
Amélioration du dynamisme des CaRCommandes CercleRayon et AngleFixe
Jusqu'à présent, on pouvait utiliser des expressions (ou des curseurs) comme coordonnées d'un point dans les différentes CaRCommandes.
On peut désormais aussi utiliser une expression (ou un curseur) comme paramètre :
* rayon de la CaRCommande CercleRayon (FixedCircle)
* mesure de la CaRCommande AngleFixe (FixedAngle)
Exemple pour le rayon :
On a donc une cohérence entre la programmation, la tortue dynamique mutante et la géométrie dynamique.
Prise en compte de la boucle répéter n fois
Cette boucle prend la forme :
répéter 10 fois {
...
}
ou
repeat 10 times {
...
}
Création et interprétation des scripts en pseud-code (apprentissage de la programmation)
A partir de la session 2018, il y a une évolution de l’écriture des algorithmes dans les sujets de baccalauréat :
- suppression de la déclaration des variables, les hypothèses faites sur les variables étant précisées par ailleurs ;
- suppression des entrées-sorties ;
- simplification de la syntaxe, avec le symbole ← pour l’affectation.
Pour information, on peut lire le document de l’Inspection Générale.
Cette évolution nous semble très judicieuse pour la lisibilité des scripts et pour faciliter l'aprentissage de la programmation. Cette syntaxe est de type Python pour l'indentation, mais l'absence de typage des variables et le "Fin de boucle" évoquent plutôt le Javascript.
On a souhaité proposer un nouvel "outil" (il s'agit plus exactement d'une fonctionnalité dans l'interprétation des scripts, à la fois en phase d'écriture et lors du lancement) pour rédiger ces scripts en pseudo-code et les interpréter. Le fonctionnement est le suivant :
Si le script commence par le texte "pseudo-code" (écrit sans guillemets), CaRMetal passe en "mode pseudo-code" :
* une coloration syntaxique est appliquée à "pseudo-code" (qui passe en gris clair)
* le script est interprété comme un script en pseudo-code
Une première conséquence de ce mode pseudo-code est la modification dynamique en phase d'écriture des suites de symboles suivantes :
<- devient ⟵
:= devient ⟵
<= devient ≤
>= devient ≥
* devient ×
Cela permet d'écrire sans effort un script en pseudo-code, script que l'on peut ensuite copier/coller dans un traitement de texte.
Mais surtout, ce script peut être interprété directement par CaRMetal :
Points importants :
3 espaces pour l'indentation des blocs (utiliser la barre espace, pas les tabulations).
Le séparateur décimal est le point (.), pas la virgule(,).
Les opérations doivent être écrites explicitement.
racine() est la racine carrée
puissance(a,b) est $a^b$
PI est PI
ln() est le logarithme népeirien
exp() est la fonctio exponentielle
arrondi() est l'arrondi à l'unité
troncature() est la troncature à l'unité
nombre_aleatoire() est un nombre aléatoire entre 0 et 1 (1 exclu).
Note pour les profs et les développeurs :
Au niveau interne, le langage utilisé dans les CaRScripts est le Javascript auquel on a ajouté un certain nombre de CaRCommandes qui font le lien avec la partie géométrique.
Les syntaxes alternatives (comme les boucles en français, le pseudo-code, etc) sont proposées en plus.
Ce qui se passe en interne, c'est que ces scripts alternatifs sont transformés en Javascript avant d'être finalement éxécutés par CaRMetal. Et il y a moyen d'afficher ce script prédigéré dans la console à l'aide de la CaRCommande getRealScript. Cette instruction est à placer en début de script de façon à ce qu'elle soit forcément exécutée même s'il y a une erreur dans le script. Elle permet de détecter un bug éventuel dans la transformation du script en syntaxe alternative (ou de s'assurer qu'il n'y a pas de bug).
On peut ressentir un léger vertige (passager) car le script est alors autoréférentiel...
On donne en pièce-jointe un fichier avec les scripts en pseudo-code de différents sujets du BAC 2017.
On a aussi la possibilité d'utiliser des CaRCommandes de géométrie et du code tortue :
Un soin particulier a été porté aux articulations et à la cohérence générale.
----------------------------------------------------------------------------------------------------------------------------
Pour s'entraîner à la programmation, on peut construire des motifs en utilisant la superposition, et si nécessaire les numéros de calques.
Ce type de construction est intéressant car il demande de changer de point de vue dans l'appréhension des figures, on retrouve dans ce cadre simple un moment essentiel de la réflexion mathématique.
Remarque : les quatre premières instructions ont le même effet que le choix ci-dessous de préférences (mais sans modifier les préférences de façon pérenne).
Version avec curseur :
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
La roue tourne :
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
La figure :
Son script (pas optimisé) :
On peut noter l'utilisation du fond coloré.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
On peut noter l'utilisation de la CaRCommande Calque, indispensable ici car sinon on a saturation sur le calque principal.
CaRMetal 4.2.2
Il s'agit d'une mise à jour mineure.
- Correction d'un petit bug de l'intersection en 3D
- Pour Mac OS seulement : correction d'un bug concernant les icônes de fichiers (qui n'apparaissent pas). Ce bug est purement visuel et n'intervient que si c'est la première installation de CaRMetal.
En bref, les fichiers CaRMetal doivent avoir ces icones de fichier :
Si c'est déjà le cas, c'est que vous n'êtes pas concernés par ce bug.
Si jamais les icones n'apparaissent toujours pas après la réinstallation, il faut supprimer le dossier caché nommé .carmetal_config (ce fichier sera recréé automatiquement), autrement dit il faut faire une "clean install" :
Supprimer le dossier de configuration (= dossier caché) .carmetal_config (ce dossier sera recréé automatiquement).
Ce dossier caché est situé dans le dossier Utilisateurs/votreNom/
Pour afficher les dossiers et fichiers caché copiez –> collez cette commande dans la fenetre du Terminal :
defaults write com.apple.finder AppleShowAllFiles 1
Puis validez avec la touche Entrer de votre clavier.
Pour masquer les dossiers et fichiers copiez –> collez cette commande dans la fenetre du terminal :
defaults write com.apple.finder AppleShowAllFiles 0
Puis validez avec la touche Entrer de votre clavier.
Attention il faut Relancer le Finder pour que les modifications soit prisent en compte !
Menu Pomme –> Forcer à quitter –> Finder –> Relancer
CaRMetal 4.2.1
1) La tortue dynamique mutante a été finalisée et est désormais bien intégrée au logiciel.
La tortue se programme dans un CaRScript.
On dispose désormais de boutons tortue dans l'assistant de scripts. Ces boutons génèrent du code tortue.
Si on active le BEGINNER Mode (case à cocher), on génère du code tortue en français (et du Javascript simplifié francisé).
Rappelons que l'on peut basculer d'un mode à l'autre à tout moment et que l'on peut écrire un code mixte, celui-ci sera correctement exécuté.
Remarque : les angles sont en degré, et les longueurs sont dans l'unité utilisée dans la figure.
1ère ligne :
Le premier bouton, qui représente une tortue sortant de son oeuf, génère la CaRCommande AttacherTortue(...). Cette CaRCommande est indispensable pour activer la tortue et/ou pour l'attacher à un point.
Viennent ensuite les traditionnels Avancer, Reculer, TournerGauche, TournerDroite.
On a enfin une CaRCommande Vitesse pour fixer la vitesse de la tortue (entre 0 et 100). Cette CaRCommande est purement cosmétique.
2ème ligne :
On a d'abord BaisserStylo, LeverStylo.
Puis viennent CacherTortue, MontrerTortue.
Enfin, on a les CaRCommandes d'orientation, absolue (orienter d'un certain angle) et en direction d'un point voire 2 points en 3D (viser).
3ème ligne :
Il s'agit de CaRCommandes de la tortue mutante. Le but est de récupérer soit le point atteint, soit le segment parcouru, soit les deux.
ligne spécifique à la 3D :
En 3D, il y a trois types de rotation : TournerGauche & TournerDroite, PivoterHaut & PivoterBas, PivoterGauche & PivoterDroite.
Les boutons génèrent le code de ces rotations.
La tortue doit toujours être attachée à un point, faute de quoi elle n'existe pas.
Tout code tortue doit donc commencer par la CaRCommande AttacherTortue(). L'argument est un nom de point qui peut déjà être dans la figure ou que l'on peut créer par script juste avant.
Si un point A existe déjà dans la figure, dans l'exemple ci-dessous le script de droite donne la figure de gauche.
Une autre méthode consiste à créer le point par script :
On va maintenant illustrer les CaRCommandes de la tortue mutante.
Imaginons que l'on souhaite construire la figure suivante :
On veut récupérer les sommets du carré.
Voici un script possible :
Si on n'avait pas mis la CaRCommande CacherTortue, la tortue resterait visible sur la figure.
Mais dès lors que l'on enregistre la figure, la tortue est désintégrée (elle disparaît visuellement au bout de quelques secondes, c'es normal), il ne reste que la construction.
Dans CaRMetal, la tortue ne se contente pas de laisser une trace, c'est un véritable outil de constuction qui produit des points et des segments qui peuvent être dynamiques.
On va maintenant illustrer ce côté dynamique de la tortue, puis son intégration avec les macros, en revisitant le classique arbre de Pythagore.
On terminera par un arbre de Pythagore 3D dépliable pour montrer le fonctionnement en 3D.
On part d'une figure avec deux points A et B, et un curseur a. Et on procède par récursivité.
L'ébauche de script ci-dessous (qui sera adaptée pour construire l'arbre) produit seulement un carré dynamique en A et B :
Mais il suffit alors de récupérer le point qui manque pour enclencher la récursion :
On obtient cette figure :
On pourrait résoudre le problème en relevant le stylo lors du tracé du segment isolé (on obtientrait alors des "feuilles" carrées comme dans l'arbre traditionnel).
On peut aussi ajouter le segment manquant en utilisant la CaRCommande Segment au bon endroit (et on obtient alors des "feuilles" triangulaires).
La figure est en p-j de l'article.
Une autre méthode pour construire l'arbre de Pythagore consiste à utiliser un script tortue pour construire une macro, et d'utiliser ensuite cette macro selon la méthode présentée dans cet article MathemaTICE. On commence par un script bien innocent :
On construit alors une macro Pytha qui a trois initiaux A,B, a et pour finaux les 4 côtés du carré et les trois points utiles à la récursion.
On va alors utiliser ExecuteMacro, et il faut d'abord établir l'ordre des finaux qu'elle renvoie.
On annule le script précédent qui a permis de créer la macro. Puis on crée un nouveau script dans le seul but de jauger l'effet de ExecuteMacro.
On voit que t[1] correspond à D, t[3] correspond à E et t[4] correspond à F.
On peut alors créer un nouveau script pour construire l'arbre :
On obtient cette figure.
Pour éviter l'apparition des derniers points, il suffit de les masquer :
Enfin, on peut choisir l'apparence par défaut des points et des segments, soit via l'interface générale et le couplage des palettes Construction et Aspect&Couleur, soit par script en utilisant la CaRCommande SetIconSelection (qui fait la même chose, mais à distance = la CaRCommande va modifier les préférences utilisateur).
La figure est en p-j de l'article.
Pour les lecteurs les plus avancés, on ajoute un tuto vidéo sur la création d'un arbre de Pythagore 3D dépliable (la figure est en p-j).
Ce tuto difficile peut être ignoré dans un premier temps. Il montre que la création d'une macro à partir d'un script tortue peut aussi être fait en 3D.
2) Apparition de la CaRCommande getRealScript
Comme on l'a dit plus haut, on peut utiliser écrire du code mixte (JS simplifié / JS, CaRCommandes en français / anglais), celui-ci sera correctement exécuté.
Avant d'être exécuté, le code du CaRScript est passé à la moulinette d'expressions régulières qui permettent ce confort d'utilisation.
Et on a la possibilité de faire afficher le code du CaRScript après l'application des RegEx, donc tel qu'il sera effectivement exécuté. Cela se fait dans un script (qui s'affiche lui-même en quelque sorte) et permettrait potentiellement de détecter une erreur qui serait due au logiciel dans l'interprétation du JS simplifié (ou de se convaincre du contraire...).
Il est conseillé de placer getRealScript dans une CaRcommande Println en début de script (de cette façon, getRealScript ne peut pas être perturbé par une erreur qui serait ultérieure dans le script).
Exemple :
------------------------------------------------------------------------------------------
Tortue vs multi-tortue : exemple des courbes de poursuite
Remarque : cette partie est dificile et peut être survolée/ignorée en première lecture.
Il y a une seule tortue dans CaRMetal, et celle-ci est à considérer comme un outil ou comme l'essence de la tortue.
Si l'on veut par exemple construire une courbe de poursuite (qui demande a priori un mode multi-tortues), on peut par exemple le faire en créant un objet javascript tortue.
Pour les afficionnados de la programmation en Javascript, voici un exemple de constructeur possible :
On peut alors utiliser ce constructeur pour créer un script multi-tortues :
Et on obtient les courbes de poursuite :
Le figure est en p-j.
CaRMetal 4.1.3
La tortue 2D et la tortue 3D peuvent désormais être utilisées dans une figure 3D.
C'est la nature du point auquel on attache la tortue qui détermine la nature de la tortue.
D'après une idée d'Alain Busser, le mouvement de la tortue a été "fluidifié" (pour une vitesse inférieure à 100, qui est la vitesse maximale).
Plus la vitesse est faible, plus la tortue décompose son mouvement, y compris pour tourner. Il s'agit d'une fonctionnalité purement cosmétique.
CaRMetal 4.1.2
La sortie de cette version est justifiée par une modification du comportement des CaRCommandes tortue Avancer() et Reculer().
Désormais, ces CaRCommandes renvoient le nom du dernier point et le nom du dernier segment créés sous forme d'un tableau Javascript (de dimension 2).
Autrement dit, on écrira :
- p = Avancer(...)[0] pour récupérer le nom du point;
- p= Avancer(...)[1] pour récupérer le nom du segment.
Si nécessaire, on crée un tableau qui contient les deux noms (pour ne pas appliquer deux fois la commande Avancer), comme pour la CaRCommande ExécuterMacro.
Les deux premiers paramètres (optionnels) de la fonction Avancer sont : le nom du point et le nom du segment.
Par ailleurs, on a ajouté la CaRCommande Libérer (redondante avec MettreFixe, mais plus simple).