Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N°40 - mai 2014 > Prise en main de CaRMetal (2/2)

Prise en main de CaRMetal (2/2)
Moteur de recherche
Mis en ligne le 30 avril 2014, par Patrice Debrabant

Cet article peut être librement diffusé à l’identique dans la limite d’une utilisation non commerciale suivant la licence CC-nc-nd
(http://creativecommons.org/licenses/by-nc-nd/3.0/fr/)

Voir Prise en main de CaRMetal 1/2

Aperçu

Dans cet article, on va s’intéresser aux points suivants dans CaRMetal :

  • les scripts ;
  • l’apprentissage de la programmation en $2^{\text{nde}}$ ;
  • la programmation en Géométrie Dynamique ;
  • la 3D (en fait pseudo-3D) .

Introduction

Rédiger un programme de tracé permettant d’obtenir une figure donnée à l’avance est un exercice classique en 6°. Cet exercice mobilise les capacités de l’élève à organiser logiquement les étapes de la construction en utilisant un vocabulaire précis et rigoureux.

Au delà de cet exercice formel, la possibilité de traduire toute construction dans un langage structuré et intelligible est un atout considérable car elle permet d’envisager la construction comme un « discours » logique plutôt que comme un simple ensemble d’objets construits.
Cela permet d’apporter après coup des ajustements au processus de génération lui-même plutôt que d’ajuster les objets déjà construits.

Mais ce n’est pas tout. En effet, le langage peut aussi accueillir des éléments (boucles, tests, etc) d’un langage de programmation sur lesquelles vont se greffer les instructions de construction.
Dans ce cas, le « discours » logique de construction deviendra un véritable « programme » de construction. Et ce programme de construction pourra créer des constructions impossibles à réaliser sans cette puissance supplémentaire conférée par un langage de programmation.

On peut même aller plus loin en développant des scripts d’action : ces scripts sont déclenchés par un événement comme le clic sur un objet, un déplacement, etc (cette potentialité, très utilisée dans les scénarii flash avec le langage ActionScript, me semble difficile à exploiter de façon pertinente en géométrie dynamique).
La fenêtre de construction devient alors événementielle (elle l’est bien-sûr déjà mais certains événements sont alors contrôlables = programmables).

L’intérêt des scripts pour la géométrie dynamique n’est plus à démontrer. La vraie question est de savoir comment les implémenter.

Avant de s’arrêter à l’implémentation proposée par CaRMetal, on va étudier brièvement celle proposée par trois autres logiciels : TracenPoche, GeoGebra et DGPad.

1) Comparatif TracenPoche, GeoGebra, DGPad

* TracenPoche

Le cas de TracenPoche est intéressant car il est emblématique d’un principe fort : le script == la construction .

Le script et la construction sont liés dynamiquement et se développent en parallèle, comme dans un miroir. Si par exemple on déplace dynamiquement un objet, le script sera modifié automatiquement pour rendre compte de cette nouvelle position.
On dispose ainsi à tout moment d’un script de la construction.

Chaque instruction dans le script traduit un outil de construction ou un paramètre d’affichage.

L’exercice du programme de tracé décrit en introduction peut être réalisé dans un cadre simple, et l’interface s’y prête très bien.
Pour obtenir la syntaxe d’un élément de script, il suffit de tracer l’objet correspondant et d’observer la mise à jour du script. Il y a une convention de nommage des nouveaux objets (par exemple dAB pour la droite passant par A et B), ce nom étant en fait indifférent et pouvant être remplacé (on pourrait être tenté de remplacer dAB par (AB), mais attention, ce n’est qu’une chaîne de caractères pour le logiciel et l’objet nommé (BA) est un autre objet, inconnu avant d’avoir été défini explicitement).

* GeoGebra

Les scripts GeoGebra sont décrits sur http://wiki.geogebra.org/fr/Script

GeoGebra propose deux langages de script :

  • un langage de script appelé GGBScript (formé d’instructions GeoGebra sans boucle) ;
  • le JavaScript de rhino (le même que dans CaRMetal).

Un script GeoGebra est toujours associé à un objet (dont il constitue une des composantes), aucun script ne peut exister sans objet.
La construction et les scripts ne sont pas liés dynamiquement : les scripts génèrent une construction, et plus précisèment (au moins en théorie) une « construction réactive » (sur le modèle événementiel).
L’interface de script et la syntaxe sont un peu difficiles à appréhender.
Si on omet le côté script objet des scripts GeoGebra (caractéristique que n’ont pas les scripts CaRMetal), l’approche est similaire à celle de CaRMetal.

* DGPad

Le cas de DGPad est intéressant car il apporte un point de vue nouveau.

DGPad est un programme écrit en JavaScript et ses scripts sont eux-même écrits en Javascript (enrichi... par du JavaScript, si l’on peut dire).
Toute figure DGPad est, en pratique, un fichier JavaScript, qui peut être lu comme un script sans besoin d’une réelle « traduction ».
Et toute modification JavaScript d’une figure est interprétable par DGPad.
Dans la version actuelle, il n’y a pas de gestionnaire de scripts (ce gestionnaire est bien évidemment attendu), et donc tout se fait manuellement dans le fichier de la figure (dont on prend le script pour le modifier et l’étoffer, avant de le réinjecter).
Cela rapproche DGPad de TracenPoche, mais DGPad a l’avantage d’avoir un accès naturel à tout le JavaScript. Ce qui a pour conséquence que l’identité entre la figure et le script souffre d’une exception : si un script produit une figure dans DGPad, celle-ci est exportée comme une figure de DGPad, cela signifie qu’elle est décrite avec les objets géométriques de base : on n’exporte pas une boucle par exemple, on exporte ce qu’a produit la boucle. Et si on reprenait le script de cette figure, on retomberait sur un script dont la boucle aurait disparu.

Se pose alors la question de la syntaxe des scripts écrits pour DGPad, et en particulier des éléments DGPad qui ne sont pas du JavaScript « pur » et sont interprétés par DGPad.
Eric Hakenholz a fait le choix d’une syntaxe très épurée et très concise, qui fait la part belle aux abbréviations et aux regroupements économiques. Au risque de s’éloigner d’un langage « naturel » (ou coutumier car analogue à celui d’autres langages de programmation).
On navigue un peu entre une syntaxe de type Javascript et une syntaxe de feuille de style [1], ce qui peut dérouter au début.
L’usage dira si c’est cette syntaxe un peu hiératique qui doit d’être assouplie ou si c’est notre façon de penser qui doit changer.
Quoi qu’il en soit, l’approche de DGPad est assurément innovante et a beaucoup d’intérêt.

2) Les scripts dans CaRMetal : l’interface Javascript

Dans CaRMetal, comme dans GeoGebra, il n’y a pas d’identité entre le script et la figure : un script construit une figure, mais la réciproque est fausse.

La fenêtre de script est un modèle d’ergonomie et de simplicité.

On peut créer un nouveau script à tout moment en utilisant l’onglet Javascript.

On donne un nom quelconque au script.

Dès lors qu’un script est créé, l’onglet Javascript donne accès à de nouvelles options :

  • feu vert : lancer le script
  • Modifier le script
  • Supprimer le script
  • Gestionnaire de scripts

L’option Gestionnaire de scripts permet de préciser à quoi on peut attacher le script.

Par défaut, le script est attaché à la figure globale CarMetal. Il est lancé manuellement (par un lien de menu) indépendamment de tout autre événement.

Mais on peut aussi l’asservir à :

  • un cliquer ou glisser de point ;
  • un cliquer (mouse up) sur un point ou un bouton ;
  • l’ouverture de la figure (= lancement automatique).

Le cliquer ou glisser (= script action) est discuté dans cet article (partie CaRMetal).
On se limitera ici au comportement par défaut (script de figure lancé manuellement).

Faisons le tour de cette interface (en partant du coin haut/gauche et dans le sens horaire) :


Taille de la police dans la fenêtre de scripts.


Commentaire javascript (court) : transforme en commentaire le passage sélectionné.
On obtient une partie de code (affiché en bleu par la coloration syntaxique) qui n’est pas active mais permet de commenter le code actif.


Indenter le script : aligne automatiquement les blocs d’instructions selon la structure logique du script.


Annule les effets du scripts.

Ajoutons à ce propos qu’il n’y a pas de bouton pour annuler l’entrée texte.
Pour réaliser cette annulation de l’entrée texte, il faut utiliser le raccourci universel Ctr Z (Cmd Z sur Mac). Signalons que cette annulation ne fonctionne pas sur les deux boutons précédents (mais elle fonctionne sur l’effet de tous les autres).


Lance/arrête le script.


Bouton aide : renvoie vers une fenêtre aide de CaRMetal.
Cette fenêtre est assez théorique et difficile à comprendre.
On pourra préférer les très bons tutoriels d’Alain Busser que voici :

On peut recommander la pratique (conjointe à la lecture) de ces tutoriels comme application pratique du présent article.



Boutons constructeurs (= CaRScripts) : il s’agit d’un assistant de script assez intuitif.
On retrouve les outils de construction bien connus.
Le détail du fonctionnement sera détaillé plus bas.

On notera la présence (en dernier) du bouton point 3D qui ne sera opérationnel qu’en mode 3D . L’icône est un peu trompeuse, ce n’est pas exactement l’équivalent de l’outil de construction point 3D. On y reviendra dans la partie 3D.



Boutons d’aspect (= CaRScripts) et autres.
On peut en détailler deux :


Le code généré par l’assistant de script est :

  1. v=InteractiveInput("Message","Point");

Ce CaRScript permet de sélctionner un objet de la construction qui sera utilisé dans la suite du script.
"Message" (ou tout autre texte) sera affiché dans la zone d’invite. "Point" (ou tout autre type d’objet) sera le type d’objet sélectionnable.


Le code généré par l’assistant est :

  1. Move("L",4,4);

Il s’agit d’un CaRScript de déplacement. Le point nommé "L" est déplacé en (4,4).
Il y a une erreur d’icône, ce n’est pas du monkey dont il s’agit ici.



Les boutons de cette zone génèrent du code Javascript.

3) Script d’une figure par CaRScripts sans JavaScript

Revenons ici sur l’exercice consistant à rédiger un programme de construction permettant d’obtenir une figure donnée à l’avance.
L’interface de scripts de CaRMetal permet de réaliser ce programme de construction en utilisant exclusivement des CaRScripts (= sans faire appel à du Javascript « pur » et en particulier aux variables Javascript).

Cette simplification permettra de bien comprendre ensuite le rôle des variables.

Imaginons par exemple que l’on souhaite écrire un programme de construction pour tracer un triangle ABC et son orthocentre H.
Il est fondamental de pouvoir invoquer un objet déjà construit dans le script.

Commençons par construire un point A en utilisant le bouton de l’assistant de script, qui génère le code :

  1. z=Point(0,3);

L’assistant génère un code mélant une variable JavaScript z et le CaRScript Point.
Ce point est nommé automatiquement par le logiciel, et le nom (une chaîne de caractère) est stocké dans z. Pour invoquer ce point, on utilisera la variable z.

Seulement, par cette procédure on ne contrôle pas le nom du point et la variable z n’est là que pour contenir le nom du point.

Il y a une syntaxe des CaRScripts constructeurs à comprendre, cette syntaxe permettant de nommer l’objet créé.
Reprenons le CaRScript Point. Ce CaRScript a deux arguments, mais il peut aussi en avoir trois, le troisième argument (qui est en fait en première position) étant le nom du point.

Ainsi, le code :

  1. z=Point("A",0,3);

construit un point nommé A (ou A* si A existe déjà comme nom d’objet).

Dès lors, pour notre programme de construction, on n’a plus besoin de la variable Javascript car on peut invoquer l’objet par son nom.
Voici le script de construction :

  1. Point("A",1,2) ;
  2. Point("B",-1,1) ;
  3. Point("C",2,-1) ;
  4. Segment("s1","A","B");
  5. Segment("s2","B","C");
  6. Segment("s3","A","C");
  7. Perpendicular("s1","d1","C");
  8. Perpendicular("s2","d2","A");
  9. Intersection("H","h1","h2");

Télécharger

Ce processus est détaillé dans cette vidéo Youtube.

Le script est un fichier texte, qui peut être envoyé par mail (cela vaut pour tous les logiciels). On est très proche de l’image communément employée pour mettre en scène cet exercice, à savoir la transmission d’une figure par téléphone.

On notera ici que les outils de construction, que l’on aura expérimentés à profit dans une phase préalable, sont réinvestis dans l’assistant de script, sans effort de mémoire inutile.
Chaque outil est traduit logiquement par un CaRScript, et dans ce cadre les CaRScripts sont utilisés sans instruction JavaScript.

4) JavaScript sans CaRScripts / Programmation en $2^{\text{nde}}$

Dans la partie précédente, on a utilisé les CaRScripts sans Javascript.
On va maintenant voir que l’interface de script permet de programmer en Javascript.
Dans un premier temps, on le fera sans CaRScript.
Dans un second, on mobilisera les CaRScripts pour rendre les choses plus ludiques (et plus visuelles).

L’apprentissage de la programmation est prévu en classe de seconde.
Aussi étonnant que cela puisse paraître pour quelqu’un qui n’aurait jamais utilisé la console JavaScript de CaRMetal, celle-ci permet d’apprendre les bases de la programmation dans d’excellentes conditions et de façon très pédagogique.

L’interface de CaRMetal permet d’apprendre et d’utiliser le Javascript, qui est un langage de programmation représentatif, et que les derniers développements d’HTML 5 assure pérenne, voire indispensable.
Cette interface est simple et agréable à utiliser.

On a la possibilité non seulement d’apprendre le Javascript lui-même mais aussi de comprendre ce qu’un langage de programmation peut apporter à un langage de scripts qui en serait dépourvu (ici le langage de CaRScripts sans Javascript dont on a montré plus haut le fonctionnement autonome possible).

Pour toutes ces raisons, on peut considérer que l’interface de scripts de CaRMetal est un choix à considérer pour l’apprentissage de la programmation [2].

Il n’est pas question ici de faire un cours de programation JavaScript.

Précisons juste quelques points particuliers du Javascript utilisé dans CaRMetal, en particulier pour les entrées/sorties :

01 – Les sorties

Les « sorties texte » (= les sorties Javascript) se font dans une fenêtre qui s’ouvre en pop up sous l’effet d’une ou plusieurs instructions Print ou Println.
Une nouvelle fenêtre est affichée à chaque exécution du script. Cette fenêtre doit être fermée manuellement.

Print affiche.
Println (pour Print Line) affiche puis fait un saut de ligne. La prochaine instruction Print affichera donc sur la ligne suivante.

Exemple de script :

  1. var x= "Juliette" ; // commentaire : var est inutile, x a une portée globale ici
  2. Println("Bonjour "+x+ ".") ;
  3. Println("1 et 1 = "+1+1) ; // premier + entre chaîne et nombre donc concaténation, idem pour le suivant
  4. Print("1 et 1 = "+(1+1)) ; // 1+1 = 2 dans la parenthèse puis concaténation

Télécharger

Résultat dans la fenêtre de sortie :

Bonjour Juliette.
1 et 1 = 11
1 et 1 = 2

Remarque : on peut aussi utiliser une fenêtre d’avertissement (qui est modale, autrement dit bloquante) en utilisant l’instruction

  1. Alert("Message");

02 – Les entrées

On peut entrer une donnée (nombre ou chaîne de caractère) de manière interactive en utilisant une instruction de type :

  1. var x=Input("message") ;

La donnée est enregistrée dans la variable x et peut être utilisée dans la suite du script.

Exemple : script pour faire calculer le carré + 1 d’un nombre

  1. var x=Input("Entrez votre nombre") ;
  2. Print("Le résultat est : " +(x*x+1)) ;

Télécharger

Résultat :

Le résultat est ...

5) JavaScript et CaRScripts / Programmation en géométrie dynamique

Généralités

Il ne reste plus qu’à faire le lien entre les deux approches précédentes.

La première chose à comprendre est que tout CaRScript constructeur est une fonction qui renvoie le nom (= une chaîne de caractères) de l’objet construit, même si cet objet est nommé automatiquement par CaRMetal.

Ainsi, si on exécute ce script :

  1. x = Point("A",2,5) ;
  2. y = Point(1,4) ;

Télécharger

alors la variable x contient la chaîne "A" et y contient le nom du deuxième point.

Et donc le script :

  1. x = Point("A",2,5) ;
  2. y = Point(1,4) ;
  3. Line(,y) ;

Télécharger

crée la droite voulue.

Le script :

  1. x = Point("A",2,5) ;
  2. y = Point(1,4) ;
  3. z= Line(,y) ;
  4. nouveauPoint= Point(2,1.5) ;
  5. i=Perpendicular(z,nouveauPoint);

Télécharger

crée aussi la perpendiculaire voulue à la droite dont le nom est contenu dans z.

Enfin, pour exemple, ce script :

  1. var P= []; // on utilise ici un tableau (de variables)
  2. var C= [];
  3. var compt= 0;
  4.  
  5. for (j=-10; j<11; j++){
  6. for (i=-10; i<11; i++){
  7. P[compt] = Point(i,j);
  8. C[compt]=FixedCircle(P[compt],0.44);
  9. SetHide(P[compt],true);
  10. SetRGBColor(C[compt],0,0,154+(Math.abs(i)+Math.abs(j))*5);
  11. SetFilled(C[compt],true);
  12. compt++;
  13. }
  14. }
  15.  
  16. for (j=-10; j<11; j++){
  17. for (i=-10; i<11; i++){
  18. P[compt] = Point(i*0.99,j*0.99);
  19. SetHide(P[compt],true);
  20. C[compt]=FixedCircle(P[compt],0.44-0.02*(Math.abs(i)+Math.abs(j)));
  21. SetFilled(C[compt],true);
  22. SetRGBColor(C[compt],255,0,0);
  23. compt++;
  24. }
  25. }

Télécharger

donne ce résultat :

La liberté est laissée à l’utilisateur de construire les figures de son choix, au gré de ses besoins ou de son inspiration.

Utilisation du caractère "underscore" (trait bas)

Pour illustrer l’utilisation de ce caractère dans les scripts, on va s’intéresser au CaRScript Polygon.

On pourrait croire que que ce CaRScript devrait avoir antant de paramètres que de sommets (+ éventuellement un paramètre pour le nommer).
Mais ce n’est pas le cas (pour des raisons que l’on ne détaillera pas ici).

Polygon a un seul paramètre : la liste des noms des sommets séparés par une virgule.
Ainsi, le script :

  1. Point("A",-4,-1);
  2. Point("B",1,5);
  3. Point("C",4,-2);
  4. m=Polygon("A,B,C");

Télécharger

construit le triangle ABC, lui donne un nom automatiquement, et affecte ce nom à m.

Mais que se passe-t-il si on commence le script ainsi ?

  1. x=Point(-4,-1);
  2. y=Point(1,5);
  3. z=Point(4,-2);

Télécharger

Il faut reconstruire la liste des noms de sommets à partir des variables. Ce qui donne :

  1. x=Point(-4,-1);
  2. y=Point(1,5);
  3. z=Point(4,-2);
  4. m=Polygon(x+","+y+","+z);

Télécharger

L’écriture

  1. m=Polygon(x+","+y+","+z);

peut être pénible à utiliser.
C’est pourquoi un mécanisme a été implémenté dans CaRMetal pour générer autrement cette écriture.
On peut aussi écrire pour le même effet :

  1. m=Polygon("_x,_y,_z");

Autrement dit, dans une expression entre guillemets, _x est remplacé par la valeur de x. Ce qui donne le script :

  1. x=Point(-4,-1);
  2. y=Point(1,5);
  3. z=Point(4,-2);
  4. m=Polygon("_x,_y,_z");

Télécharger

On notera que l’on peut utiliser des expressions en lieu et place des expressions numériques, comme on l’a illustré dans la partie 1/2 de ce tutoriel (cela sera utilisé plus bas pour la 3D).
Et dans ce contexte, il existe un autre mécanisme implémenté avec l’underscore.

  1. a=Point(1,2);
  2. t="x("+a+")";

Télécharger

peut être écrit ainsi :

  1. a=Point(1,2);
  2. t="x_a";

Télécharger

Cela permet de construire rapidement un barycentre qui reste dynamique. Exemple :

  1. a=Point(1,2);
  2. b=Point(-1,3)
  3. z=Point("0.25*x_a+0.75*x_b","0.25*y_a+0.75*y_b");

Télécharger

Pour aller plus loin

Vous trouverez sur mathémaTICE, sur le site de CaRMetal et sur le site de l’IREM de la Réunion des tutoriels, des documents de référence, et beaucoup d’exemples sur les CaRScripts. Ils vous permettront d’aller plus loin.

Dans le cadre d’une utilisation en analyse, je vous recommande en particulier les deux vidéos Youtube suivantes, réalisées par Alain Busser :

vidéo partie 1
vidéo partie 2

6) La récursivité

Cette partie est traitée dans cet autre article.
Un cas plus compliqué (3D) est traité dans cet article du même numéro.

7) La pseudo-3D

CaRMetal est un logiciel de pseudo-3D : en mode 3D, on dispose d’un trièdre mobile (O,X,Y,Z) pilotable par clic droit dans l’espace 2D.
En projetant sur ce trièdre, on peut représenter n’importe quel point 3D.

Le CaRScript Point(s,t) crée un point de coordonnées (s,t) par effet de bord.
s et t peuvent contenir des expressions CaRMetal. Par exemple, Point("x(A)", "y(A)") construit un doublon du point A (qui doit déjà être construit pour que les expressions x(A) et y(A) soient reconnues).

Pour un point M(a,b,c) de l’espace, on a : $M = O + a\overrightarrow{OX} +b\overrightarrow{OY} + c\overrightarrow{OZ}$.

On peut alors créer le projeté d’un point de l’espace de coordonnées (a,b,c) par l’instruction suivante [3] :

Point("x(O)+("+a+")*(x(X)-x(O))+("+b+")*(x(Y)-x(O))+("+c+")*(x(Z)-x(O))","y(O)+("+a+")*(y(X)-y(O))+("+b+")*(y(Y)-y(O))+("+c+")*(y(Z)-y(O))");

Certains outils 2D appliqués à ces points se comportent alors comme des outils 3D (milieu, segment, droite, polygone,...)
Et de cette manière, on peut faire de la 3D dans l’espace 2D.

Pour exploiter la création des points 3D, il est très utile de programmer l’équivalent d’un CaRScript Point3D.
Différentes méthodes ont été proposées.

Celle que je présente ici n’est pas officielle :

Point3D

  1. var Point3D = function (a,b,c) {
  2. var that= {};
  3. that.x = a;
  4. that.y = b;
  5. that.z =c;
  6. that.name= Point("x(O)+("+a+")*(x(X)-x(O))+("+b+")*(x(Y)-x(O))+("+c+")*(x(Z)-x(O))","y(O)+("+a+")*(y(X)-y(O))+("+b+")*(y(Y)-y(O))+("+c+")*(y(Z)-y(O))");
  7.  
  8. that.getX3D = function () {
  9. return that.x;
  10. }
  11. that.getY3D = function () {
  12. return that.y;
  13. }
  14. that.getZ3D = function () {
  15. return that.z;
  16. }
  17. that.getName2D = function () {
  18. return that.name;
  19. }
  20.  
  21. return that;
  22. };

Télécharger

Cette fonction s’utilise comme le CaRScript Point() mais crée un point 3D et renvoie un objet JavaScript.
La propriété name donne le nom du projeté dans l’espace 2D.

Dans certains cas (=pour les calculs), on ne voudra pas que le point 2D soit créé par effet de bord. On va donc créer une fonction Point3Dc analogue (convention : suffixe c pour calcul), mais sans création du projeté :

  1. var Point3Dc = function (a,b,c) {
  2. var that= {};
  3. that.x = a;
  4. that.y = b;
  5. that.z =c;
  6.  
  7. that.getX3D = function () {
  8. return that.x;
  9. }
  10. that.getY3D = function () {
  11. return that.y;
  12. }
  13. that.getZ3D = function () {
  14. return that.z;
  15. }
  16.  
  17. return that;
  18. };

Télécharger

Ces deux fonctions peuvent alors être exploitées dans un script.
Un exemple d’application est donné dans cet article du même numéro déjà cité (on pourra noter que cet article donne une idée de ce que l’on peut faire avec les scripts CaRMetal, appliqués ou pas à la 3D).


Voilà. Cet article n’est qu’une introduction aux scripts de CaRMetal.
Si vous avez des questions, n’hésitez pas à venir les poser sur le forum.


notes

[1on notera encore l’analogie avec TracenPoche.

[2Une interface Python en est un autre. En revanche, -ce n’est qu’une opinion-, l’approche d’Algobox peut sembler artificielle et moins vivifiante.

[3cette idée revient à Jérôme Caré.

Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197