CaRScript

DrGeo est muni d'un langage de script, permettant de construire notamment des fractales. Ce langage issu de Lisp est basé sur la récursivité et n'est pas très emblématique de la démarche algorithmique. Mais la suite, DrGeoII, est dotée du langage SmallTalk (qui est un langage objet, donc pas tout à fait conforme aux attendus du programme d'algorithmique).

Kig est lui aussi muni d'un langage de script, à savoir Python. Ce langage de script est un langage objet ce qui peut le faire trouver un peu compliqué pour un usage en classe.

TracenPoche permet de construire les objets à l'aide de boutons mais également à l'aide du script qui constitue la véritable définition de la figure. La syntaxe qui a été choisie est proche de la syntaxe naturelle :

Nom_objet = Nature_Objet(Paramètres) { options d'affichage }.

Une particularité de TracenPoche est l'interactivité dans les deux sens, entre la figure et le script (le sens allant de la figure au script est inédit). Par contre le langage de script de TracenPoche ne permet pas d'écrire des boucles à condition d'arrêt (boucles Tant que).

Cinderella (logiciel) est depuis la version 2, muni de son propre langage de script appelé CindyScript. CindyScript est un langage procédural donc adapté à l'enseignement de l'algorithmique dans l'enseignement secondaire.

CaRMetal utilise pour langage de script, JavaScript, langage proche de Java, C++, le langage de programmation de Xcas mais aussi du langage Asymptote.

Géoplan/Géospace peut être piloté par le langage de script Vbscript de Microsoft. Des boutons peuvent ainsi créer, détruire ou manipuler des objets depuis un document externe à l'application, comme une présentation ou un tableur. La technique n'a cependant pas été adoptée au-delà d'un petit cercle d'initiés, permettant par exemple des imagiciels où la réponse de l'étudiant est validée depuis l'extérieur.

Les objets créés dans les CaRScripts sont en général des objets de type chaîne de caractères. Par exemple,

a=Point(2,3);

crée un point et met son nom dans la variable a. Les coordonnées initiales du point sont 2 et 3 mais celui-ci peut bouger avec la souris puisqu'il n'a pas été fixé. On peut aussi créer en programmation procédurale par

Point("A",2,3);

Une fois que le nom d'un objet est stocké dans une variable, il est possible de faire appel à cette variable pour utiliser l'objet. Par exemple

a=Point(2,3); SetHide(a,true);
b=Point(4,5); SetPointType(b,"cross");
s=Segment(a,b);

L'effet est de cacher le premier point et de donner au second point une forme de croix puis de construire le segment joignant ces deux points, segment dont le nom est stocké dans la variable s.

Les constructions telles que Point s'obtiennent en cliquant sur des icônes à droite de l'éditeur JavaScript et ce faisant on obtient un exemple tout fait qu'on n'a plus qu'à modifier. Ce remplacement de la création par la modification est un paradigme issu du monde de la technologie: Choisir un outil dans une boîte à outils est plus rapide qu'avoir à construire l'outil.

Pour afficher le contenu d'une variable numérique (utile pour le débogage) on dispose de la fonction Println mais aussi de la possibilité d'ouvrir une fenêtre d'affichage de données avec Alert(). Ainsi, pour savoir ce que contient la variable x, on a le choix entre

Println(x);
Alert(x);

En réalité, l'objet affiché est une chaîne de caractères, au besoin convertie automatiquement depuis un autre type, et il est possible d'obtenir des affichages complexes avec la concaténation de chaînes. Une entrée de données est également possible, soit avec Input qui ouvre une boîte d'entrée de données, soit avec InteractiveInput qui demande à l'utilisateur de sélectionner un objet géométrique de la figure, en cliquant dessus. Ces instructions en JavaScript s'obtiennent en cliquant sur les entrées correspondantes dans le menu en bas à droite de l'éditeur JavaScript.

Dans les exemples ci-dessus, les coordonnées des points sont données sous forme numérique. En fait elles sont automatiquement converties en chaînes de caractères, et il est tout à fait possible d'entrer les coordonnées des points directement sous forme de chaînes de caractères! Et dans ce cas, écrire la chaîne dans le langage de CaRMetal permet de créer par programme des objets dynamiques. Par exemple

a=Point("2.72","3.14");
b=Point("round(x_a)","round(y_a)");

Deux points sont créés, l'un mobile, l'autre qui suit le premier, mais en gardant des coordonnées entières (c'est donc un entier de Gauss). Comme on ne sait pas d'avance comment CaRMetal a nommé le point, on peut avoir son abscisse avec "x("+a+")"qu'on peut abréger en x_a.

Il est possible de donner à un objet un aspect qui dépend du résultat d'un test, comme dans ce début (le calcul n'est pas effectué) d'implémentation du calcul de pi par la méthode de Monte-Carlo:

for(n=1;n≤100;n++){
	x=Math.random();
	y=Math.random()
	p=Point(x,y);
	if(x*x+y*y<1){
		SetColor(p,"red");
	} else {
		SetColor(p,"blue");
	}
}

La syntaxe des boucles par JavaScript n'est pas des plus simples, mais elle permet facilement d'avoir des boucles où l'indice ne suit pas une progression arithmétique, comme dans cette liste des nombres premiers de la catégorie nombre de Fermat:

for(p=1;p≤16;p*=2){
	Println(Math.pow(2,p)+1);
}

Pour obtenir une boucle à condition de sortie, on clique sur while ou sur do..while dans le menu JavaScript en bas à droite. Ces boucles sont utiles pour fabriquer des figures récursives mais aussi pour simuler les boucles à nombre prédéfini d'exécutions:

for(i=1;i≤10;i++){
	Println(i);
}

a le même effet que

i=1;
while(i≤10){
	Println(i);
	i=i+1;
}

Le script du triangle de Sierpinski est assez court en CaRMetal grâce à l'abondance d'instructions graphiques toutes faites:

a=Point(-4,-2);
b=Point(4,-2);
c=Point(0,4);
m=Point(Math.random(),Math.random());
SetHide(m,true);
for(n=0;n≤2000;n++){
	dé=Math.ceil(Math.random()*3);          //dé à trois faces!
	switch(dé){
		case 1: {p=MidPoint(a,m); break;
		}
		case 2: {p=MidPoint(b,m); break;
		}
		case 3: {p=MidPoint(c,m); break;
		}
	}
	SetPointType(p,"point");
	m=p;
}

Seulement la figure est dynamique: On peut bouger les trois premiers points construits et le nuage de points suit le mouvement.

Les objets de type array sont utiles pour stocker les noms ou les coordonnées de points (utile pour construire des objets dans l'espace, puisque CaRMetal gère les arêtes cachées), ou pour faire de la statistique dans un contexte graphique (recherche de distances médianes ou moyennes par exemple)

Les objets de type String et les RegExp à la Perl sont gérées par l'éditeur de CaRMetal, ce qui permet de simuler une tortue LOGO et de construire des figures basées sur les L-Systèmes[1].

Grâce aux objets de type Date de JavaScript, CaRMetal sait quelle heure il est, ce qui permet de faire entrer le temps qui passe dans la figure. Il est possible par exemple d'incorporer une horloge à aiguilles tournantes dans une figure dynamique!

Une procédure est une fonction sans l'instruction return. Une fonction (éventuellement de plusieurs variables) peut très bien s'appeler elle-même, devenant ainsi récursive. Voici comment CaRMetal peut calculer récursivement un pgcd:

function pgcd(a,b) {
                if ((b % a) == 0){
                        return (a);
                } else {
                        return (pgcd(a,b-a));
                }
}

Comme en JavaScript les objets sont définis comme des fonctions, il est possible de créer des objets comme par exemple le type nombre complexe dont ci-dessous seule la méthode dessine est implémentée (il manque au moins les méthodes somme, produit, inverse et conjugué!):

function complexe(x,y){
	//attributs de l'objet complexe:
	this.real=x;
	this.imag=y;
	this.modulus=Math.sqrt(x*x+y*y);
	this.argument=Math.atan2(y,x);
	//méthodes de l'objet complexe:
	this.dessine=function(){//dessine le point
		p=Point(x,y);
	} 
	this.conjugate=function(){//renvoie un complexe
		return new complexe(x,-y);
	}
	this.inverse=function(){//renvoie un complexe
		return new complexe(x/(x*x+y*y),-y/(x*x+y*y));
	}
}
//Les opérations ne peuvent pas être des méthodes de l'objet
// "complexe" parce qu'elles attendent 2 complexes 
function complexe_somme(a,b){//a et b sont des complexes 
	return new complexe(a.real+b.real, a.imag+b.imag)
}
function complexe_produit(a,b){//a et b sont des complexes
	var r=a.real*b.real-a.imag*b.imag;
	var i=a.real*b.imag+a.imag*b.real;
	return new complexe(r,i);
}
function complexe_quotient(a,b){
	return complexe_produit(a,b.inverse());
}
 
var z = new complexe(3,2);
z.dessine();
Println(z.argument*180/Math.PI);
var zbar = z.conjugate();zbar.dessine();
var zsomme=complexe_somme(z,zbar);
var u=complexe_quotient(z,zbar);
u.dessine();

Bien que ${\displaystyle z+{\bar {z}}\in \mathbb {R} }$, l'objet zsomme n'est pas considéré comme réel, mais comme un complexe de partie imaginaire nulle. Par ailleurs, les macros de CaRMetal sur les nombres complexes sont meilleures que ces objets parce que les points créés par ces macros suivent le mouvement lorsqu'on bouge les objets initiaux à la souris, ce qui n'est pas le cas avec ces méthodes.

On peut néanmoins aller plus loin dans l'interaction entre les objets créés par CaRScript et CaRMetal.

• C.a.R.
• CaRMetal
• JavaScript
• Programmation orientée objet

• Rubrique sur les CaRScripts sur le site de l'IREM de La Réunion, avec un tutoriel et un manuel de référence
• Des CaRScripts de statistique en Seconde
• Article introductif sur Mathematice
• Utilisation d'objets en JavaScript pour fabriquer des motifs de cube (le topic suivant reprend l'idée avec un dodécaèdre)
• Un CaRScript créé par un élève de Seconde avec l'effet rendu en vidéo.

• JavaScript, David Flanagan, éditions O'Reilly
• Bulletin Vert n^o 487 de l'APMEP, mars 2010: Article sur des CarScripts en classe