CaRScript

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

Un CaRScript est un script pour le logiciel de géométrie dynamique CaRMetal. Le terme est un néologisme obtenu par apocope et aphérèse sur l'expression "CaRMetal-JavaScript". Le langage des CaRScripts est donc JavaScript. Mais des instructions spécifiques à la géométrie dynamique sont incluses dans la boîte à outil des CaRScripts, ce qui tend à donner des codes courts, par rapport à l'effet produit. Et l'usage conjoint du langage de scripts et de la géométrie dynamique permet d'avoir des figures à la fois complexes et dynamiques.

Scripts et géométrie dynamique[modifier | modifier le code]

DrGeo[modifier | modifier le code]

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[modifier | modifier le code]

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

Tracenpoche[modifier | modifier le code]

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[modifier | modifier le code]

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 en Lycée.

CaRMetal[modifier | modifier le code]

CaRMetal utilise pour langage de script, JavaScript, langage proche de Java (langage), c++, le langage de programmation d'xcas mais aussi du langage Asymptote (langage de dessin vectoriel).

Géoplan/Géospace[modifier | modifier le code]

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.

Création d'objets géométriques[modifier | modifier le code]

Type des variables[modifier | modifier le code]

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.

Variables numériques[modifier | modifier le code]

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.

Écriture dans le langage de CaRMetal[modifier | modifier le code]

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.

Boucles[modifier | modifier le code]

Tests[modifier | modifier le code]

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");
	}
}

Boucles à nombre prédéterminé d'exécutions[modifier | modifier le code]

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

Boucles à condition de sortie[modifier | modifier le code]

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;
}

Exemple[modifier | modifier le code]

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++){=Math.ceil(Math.random()*3);          //dé à trois faces!
	switch(){
		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.

Objets JavaScript[modifier | modifier le code]

Tableaux[modifier | modifier le code]

Article détaillé : Tableau (structure de données).

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)

Expressions rationnelles[modifier | modifier le code]

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-systems[1].

Date[modifier | modifier le code]

Article détaillé : ISO 8601.

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!

Fonctions et objets[modifier | modifier le code]

Articles détaillés : JavaScript et Programmation orientée objet.

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 z + \bar {z} \in \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.

Notes et références[modifier | modifier le code]

  1. Des exemples sont visibles avec ces CARScripts en ligne : [1], en particulier le troisième article, où on construit des L-systèmes manipulables dynamiquement par des curseurs, pendant la construction.

Annexes[modifier | modifier le code]

Sur les autres projets Wikimedia :

Articles connexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]

Bibliographie[modifier | modifier le code]

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