Pour réaliser une construction géométrique en quelques clics avec GeoGebra, ou avec tout autre logiciel de géométrie dynamique, il est assez simple d’utiliser les nombreux outils disponibles dans la barre d’outils. C’est ce que nous apprenons à faire à nos élèves et la plupart de ces outils sont assez simples et rapides à prendre en main. Mais tous ces outils sont également accessibles par des commandes à saisir, ce qui permet de « programmer » une construction. Je ne parle pas ici de JavaScrispt, qui est aussi une possibilité, mais de commandes propres à GeoGebra.

Un clic sur le bouton qui contient ce script de 10 commandes permet d’obtenir la construction ci-contre.

Parmi ces commandes, une des plus avancées, mais aussi des plus complexes à s’approprier, est la commande Séquence(). Elle n’a pas d’équivalent en outil utilisable par quelques clics : il s’agit ici uniquement de programmer. Bien maitrisée, en une ligne d’instructions, elle permet de créer une liste d’objets (de même nature) ou de valeurs définis selon un algorithme précis. Cette commande se rapproche beaucoup d’une boucle « répéter » (boucle bornée for en Python, par exemple), outil qui manque souvent lorsqu’on développe une appliquette un peu élaborée.

Dans cet article, je vais tenter de familiariser le lecteur avec cette commande en montrant plusieurs exemples d’applications différents et en faisant, lorsque c’est possible, un parallèle avec PyGGb qui permet de programmer en Python une construction géométrique GeoGebra et qui permet donc l’usage de boucles bornées (je parle de PyGgb dans cet autre article). Le but de ce parallèle est de bien faire comprendre le fonctionnement de la commande Séquence() et non pas de comparer les deux outils. Cela ne sera possible seulement lorsque nous parlerons de créer des listes d’objets géométriques. Dans le cas de liste numérique, je montrerai l’équivalent en langage Python.

La plupart de ces exemples ne seront pas forcément directement utiles à l’enseignant, mais sont à considérer comme des exercices de prise en main de l’outil. Je recommande vivement au lecteur d’ouvrir GeoGebra et de saisir les commandes indiquées tout au long de cette première partie : la compréhension et l’appropriation de cette commande n’en seront que plus efficaces.

Je donnerai ensuite, dans la seconde partie de l’article, quelques exemples concrets où la commande Séquence() peut-être utile pour la création efficace de contenus pédagogiques, tels que des axes gradués ou des graphiques. Enfin, dans une dernière partie un peu plus technique, je montrerai ce que permet de réaliser l’association de la commande Séquence() avec la commande Exécute() et les interactions possibles avec le tableur de GeoGebra.

 Un œil dans le manuel GeoGebra

Premier réflexe à adopter systématiquement lorsque l’on veut en savoir plus sur une commande ou un outil de GeoGebra : aller lire la page dédiée du manuel. Celui-ci a récemment migré sur github et la page correspondant à notre sujet est ici (j’en profite pour saluer l’énorme travail de Noël Lambert sur la version française de ce manuel !).

Premier constat, on compte cinq syntaxes différentes pour cette commande :

• Séquence( <Expression e>, <Variable k>, <de a>, <à b> )
• Séquence( <Expression e>, <Variable k>, <de a>, <à b>, <pas p> )
• Séquence( <Entier final n > )
• Séquence( <Entier initial i >, <Entier final n > )
• Séquence( de, à, pas )

Les trois dernières, très similaires permettent de créer une liste de nombres avec ou sans l’indication de la valeur initiale et du pas.

Les deux premières permettent d’utiliser une expression au sens large : il peut s’agir d’une expression algébrique, mais également une expression contenant des commandes GeoGebra. Une variable peut être utilisée dans cette expression : on en donne la valeur initiale et la valeur finale avec, la possibilité de préciser le pas s’il est différent de 1.

Comme ressource complémentaire, n’oublions pas l’indispensable brochure Créer avec GeoGebra de la Commission inter IREM TICE, dans laquelle la commande Séquence() est détaillée aux pages 534 et 535 (Fiche technique 17, « Listes et matrices ») : les syntaxes précédentes y sont explicitées.
Téléchargement de la brochure sur cette page du nouveau site de la commission (hébergé sur la Forge) qui est en cours de construction au moment où j’écris ces lignes.

 Créer une liste de nombres

Il s’agit de l’application la plus simple de cette commande et celle sur laquelle je passerai le plus rapidement.

Premier exemple, la séquence Liste1 = Séquence(7) crée la liste « Liste1 = 1, 2, 3, 4, 5, 6, 7 ». Cette liste est visible dans la fenêtre Algèbre.

On remarquera que GeoGebra commence à compter à partir de 1 et non à partir de 0 comme le ferait Python. Ici, PyGGb n’a que très peu d’intérêt puisque cette liste ne peut pas être affichée dans la fenêtre graphique. Mais si on reste seulement avec Python, on peut comparer cette commande avec les deux programmes ci-dessous, qui génèrent la même liste de nombres :

Nous pouvons ajouter dans la syntaxe le premier nombre de la liste souhaitée, s’il est différent de 1.

Par exemple, la séquence Liste2 = Séquence(5,12) crée la liste « Liste2 = 5, 6, 7, 8, 9, 10, 11, 12 ».

Il est à noter que l’on peut créer cette dernière liste plus rapidement en saisissant simplement Liste2 = 5…12 alors que la première liste pouvait être créée par la commande Liste1 = 1…7.

En langage Python, nous utiliserions un des deux programmes suivants :

Enfin, il est possible d’ajouter le pas d’incrémentation de la variable dans la syntaxe si on le souhaite différent de 1. Ainsi, la séquence Liste3 = Séquence(5, 30, 4) crée la liste « Liste3 = 5, 9, 13, 17, 21, 25, 29 ».

Encore une fois, en langage Python, on obtient la même liste avec les deux programmes ci-dessous :

 Créer des listes d’objets

  Liste de points sur une courbe

Dans GeoGebra pour créer un point par une saisie, il suffit de donner ses coordonnées. Par exemple, saisir (2,5) créera le point de coordonnées (2 ; 5) qui sera nommé dans l’ordre alphabétique (si aucun objet ne se nomme déjà « A », il le sera, sinon il aura pour nom la première lettre majuscule disponible). Saisir M = (2,5) permet de choisir le nom du point. Il faut bien utiliser une virgule comme séparateur entre l’abscisse et l’ordonnée.

Maintenant si nous voulons obtenir une série de points sur la parabole d’équation y = x², nous pouvons utiliser la fonction « Séquence ». La saisie de ListePoints1 = Séquence((i,i^ 2), i, -3, 3) crée une liste de 7 points qui sont visibles dans la fenêtre graphique.

Plusieurs remarques importantes :

• Dans Séquence((i,i^ 2), i, -3, 3), le premier argument (i,i^ 2) est l’expression (ici les coordonnées du point à créer), le second argument i est la variable, les deux arguments suivants -3 et 3 sont la valeur initiale prise par i et sa valeur finale.
• Une interprétation de la commande serait : « créer les points de coordonnées (i ; i²) pour i variant de -3 à 3 avec un pas de 1  » (ce dernier n’étant pas précisé).
• « x » ne peut pas être utilisé comme variable dans la saisie d’une séquence. C’est pourquoi j’ai utilisé « i ».
• La liste ainsi créée forme un seul et unique objet : il n’est pas possible de masquer certains de ces points seulement ou de changer la couleur de seulement quelques-uns. Je reviendrai sur ce point dans la dernière partie de l’article : il est en effet possible de le contourner.
• Par contre, chaque point est accessible dans la liste. Par exemple A = ListePoints1(2) créera le point A de coordonnées (-2 ; 4), deuxième point de la liste.
• Si la fonction définie par f(x) = x² a déjà été créée (avec la saisie de f(x)=x^2) alors on obtient la même série de points avec la commande ListePoints1 = Séquence((i,f(i)), i, -3, 3).
• Nous pouvons ajouter un dernier argument qui donnera le pas pour l’incrémentation de la variable. Ainsi, la séquence ListePoints2 = Séquence((i,i^ 2), i, -3, 3, 0.5) donnera 13 points de la parabole.

Avec PyGgb, la fonction « Point(x,y) » permet de créer un point à partir de ses coordonnées et nous l’intégrons donc dans une boucle bornée en faisant attention au fait que le pas doit être un nombre entier. Cela donne ceci, pour obtenir le même résultat que le tout dernier exemple (avec un pas de 0,5) :

  Liste de points sur un cercle

Pour créer un point avec ses coordonnées polaires, dans GeoGebra, il faut utiliser le point-virgule comme séparateur entre le rayon polaire et l’angle. Nous pouvons ainsi obtenir des points régulièrement répartis sur un cercle de rayon 3 unités, centré sur l’origine, avec la commande Séquence((3 ; i), i, 0°, 350°, 10°) :

Plusieurs remarques importantes :

• Une interprétation de la commande serait : « créer les points de coordonnées polaires (3 ; i) pour i variant de 0° à 360° avec un pas de 10° ».
• Si l’unité d’angle n’est pas indiquée, GeoGebra considère qu’il s’agit de radians. Si on travaille en degrés, comme ici, l’unité doit être précisée.

Les coordonnées polaires ne sont pas supportées par PyGgb. On doit donc calculer les coordonnées cartésiennes en convertissant les degrés en radians. On obtient le même résultat que ci-dessus avec le programme suivant :

Si nous revenons avec GeoGebra, nous pouvons obtenir la même liste de points en réalisant des rotations de centre (0 ; 0) du point de coordonnées (3 ; 0).
La séquence est alors : Séquence(Rotation((3, 0), i, (0, 0)), i, 0°, 350°, 10°).

Ou bien encore : Séquence(Rotation((3, 0), i°, (0, 0)), i, 0, 350, 10).

En effet, l’unité (degré) peut être indiquée sur la variable, dans l’expression.

Remarque : la commande Rotation() admet 3 arguments. Dans l’ordre : l’objet dont on cherche l’image (ici le point de coordonnées (3 ; 0)), l’angle et le centre de la rotation (ici l’origine du repère).

Avec PyGgb la seule différence sur le résultat obtenu, en utilisant également des rotations, est que le centre de la rotation sera lui aussi créé :

Et pour continuer sur cet exemple, il est possible que l’expression de la séquence soit elle-même une séquence. Par exemple,
 Séquence(Séquence((r ; i), i, 0°, 350°, 10°), r, 0.2, 3, 0.2)
nous donnera un réseau de points sur des cercles concentriques.

La séquence imbriquée Séquence((r ; i), i, 0°, 350°, 10°) crée une série de points sur le cercle de rayon r. Ce rayon variant dans la séquence principale de 0,2 à 3 unités.

Dans PyGgb, on peut utiliser deux boucles imbriquées pour obtenir le même résultat :

On peut varier les plaisirs en faisant varier le rayon et l’angle avec une seule variable pour obtenir une jolie spirale : Séquence((3i / 360 ; i°), i, 0, 360, 5). Ici, l’unité — le degré — doit être déclarée dans l’expression puisque la variable est une première fois utilisée comme un nombre puis une seconde fois comme un angle.

Le programme suivant permet d’obtenir la même construction avec PyGgb :

Autre variation possible, nous pouvons tracer de belles cardioïdes en reliant ces points selon la méthode décrite par Mickaël Launay dans cette vidéo pour représenter les tables de multiplication.

Pour cela, la commande Segment(Point1, Point2) permet de tracer le segment dont les extrémités sont les deux points spécifiés en arguments par leurs noms ou leurs coordonnées. Nous allons utiliser leurs coordonnées polaires. Je profite de cet exemple pour indiquer que les listes créées avec une séquence sont dynamiques. On peut ici, par exemple, commencer par créer 2 curseurs :

• « nbP » qui sera le nombre de points sur le cercle ;
• « n » qui sera le nombre dont on souhaite représenter la table.

Avec la séquence ci-dessous, on obtient une belle figure dynamique : elle est mise à jour à chaque modification des valeurs des curseurs.

Séquence(Segment((1; i° * 360 / nbP), (1; n i° * 360 / nbP)), i, 0, 360, 360 / nbP)

Le résultat (appliquette interactive à manipuler) :

Sur le même thème, voir également cet exemple, un peu plus élaboré.

  Un réseau de points

Pour finir avec les points, une remarque qui peut être utile : il est possible de créer un point sur une liste d’objets. On peut utiliser l’outil « Point sur Objet » ou bien la commande Point( <Objet> ) dans laquelle «  » est à remplacer par le nom de la liste d’objet (déjà créée, avec une séquence ou pas).

Nous obtenons alors un point semi-libre : il ne peut être déplacé que d’objet en objet de la liste.

Par exemple, nous pouvons créer un réseau de points avec la séquence suivante :
Séquence(Séquence((i, j), i, 0, 5), j, 0, 5)

En créant ensuite un point A sur cette liste de point, nous obtenons le fichier ci-dessous. Il peut être utile de remarquer que la contrainte sur le point A est la même que le réseau de points soit affiché ou pas.

Le résultat (appliquette interactive à manipuler) :

  Des polygones

Un grand classique de l’utilisation des séquences est la construction de polygones réguliers ayant un côté commun et un nombre de sommets différents. La séquence suivante nous donne ainsi 10 polygones réguliers, du triangle au dodécagone : Séquence(Polygone((0,0), (2, 0), n), n, 3, 12).

Remarque : la commande Polygone((0,0), (2, 0), n) permet de créer un polygone régulier à n côtés dont l’un a pour extrémités les points de coordonnées (0 ; 0) et (2 ; 0).

Dans PyGgb, les sommets des polygones sont créés :

Je profite de cette construction pour faire remarquer une nouvelle fois que les séquences créent des objets dynamiques. Par exemple, si je commence par créer un curseur nommé « nmax » qui prend les valeurs de 3 à 20, alors la séquence Séquence(Polygone((0,0), (2, 0), n), n, 3, nmax) sera actualisée lors du déplacement du curseur qui permet alors de choisir combien de polygones sont construits.

Le résultat (appliquette interactive à manipuler) :

  Un pavage

Une autre utilisation intéressante des séquences est la réalisation de pavages.

Pour réaliser un pavage hexagonal, par exemple, des translations dans deux différentes directions sont nécessaires. Nous allons commencer par déterminer les vecteurs associés à ces deux translations.

La hauteur de l’hexagone (distance entre deux côtés opposés) est égale au double de son apothème qui vaut $c×\frac{\sqrt(3)}{2}$ où c est la mesure du côté.

Si on considère un hexagone de côté 2 unités, le vecteur translation à utiliser pour la translation verticale a pour coordonnées $\overrightarrow{AB}\left( \begin{array}{}0\\2\sqrt{3}\end{array}\right) $.

Dans la seconde direction, on détermine de même le vecteur associé à la translation : $\overrightarrow{AC}\left( \begin{array}{}3\\ \sqrt{3}\end{array}\right)$.

On peut commencer par tester les deux translations dans deux séquences indépendantes :

Séquence(Translation(Polygone((0,0), (2, 0),6), (0, 2*n*sqrt(3))), n, 0, 5)

et Séquence(Translation(Polygone((0, 0), (2, 0), 6), (3*m, m*sqrt(3))), m, 0, 5).

Il faut noter que les images créées par la translation sont toutes celles du polygone de départ Polygone((0,0), (2, 0),6). C’est pourquoi les variables n et m doivent intervenir dans les coordonnées des vecteurs associés aux translations.

On obtient les deux résultats suivants :

Nous pouvons maintenant imbriquer les deux séquences :

Séquence(Translation(Séquence(Translation(Polygone((0, 0), (2, 0), 6), (3*m, m*sqrt(3))), m, 0, 5),(0, 2*n*sqrt(3))),n,0,5)

Nous obtenons alors le pavage attendu avec une seule commande :

Il est ici possible de s’éviter d’imbriquer les deux séquences en nommant, par exemple, T1 la première séquence :

T1 = Séquence(Translation(Polygone((0, 0), (2, 0), 6), (3*m, m*sqrt(3))), m, 0, 5)

Puis en réalisant la translation de l’objet ainsi créé :

Séquence(Translation(T1, (0, 2*n*sqrt(3))), n, 0, 5)

Et dans cet exemple encore, l’utilisation de curseurs peut rendre dynamique ce pavage. Le résultat (appliquette interactive à manipuler) :

Malheureusement, il n’y a pas de fonction sous PyGgb permettant de réaliser une translation (en tout cas pas à ma connaissance).

 Quelques applications utiles pour la classe

Il n’est pas question ici de faire utiliser cette commande Séquence() aux élèves : elle est trop complexe et elle n’est indispensable qu’aux personnes souhaitant réaliser des fichiers assez élaborés. Elle peut par contre permettre à l’enseignant de gagner du temps dans la réalisation de documents à imprimer (création de graphiques, par exemple) ou d’appliquette, comme des exerciseurs.

  Un générateur d’axes gradués

La création d’axes gradués pour faire travailler le repérage sur la droite ou la demi-droite graduée au collège peut être chronophage. L’utilisation de séquences peut faire gagner beaucoup de temps pour créer une appliquette qui nous permettra de créer des exercices de lecture d’abscisses, en en faisant une capture d’écran ou un export dans un des formats d’images disponibles dans GeoGebra.

Voici l’appliquette interactive que nous allons réaliser :

L’idée de ce que je propose est d’utiliser deux séquences : l’une pour créer les graduations principales (graduation unitaire) et l’autre les graduations secondaires (partage de l’unité). Mais avant cela, il faut préparer le fichier :

• Créer 3 curseurs (a, b et c) qui permettront de paramétrer la construction suivant ce que l’on souhaite obtenir.

• Créer ensuite un vecteur horizontal de coordonnées $\left( \begin{array}{}0\\a\end{array}\right) $, il représentera notre axe. Le premier curseur servira ainsi à choisir la longueur de l’axe gradué. J’ai représenté ce vecteur tel que son origine soit positionnée sur l’origine du repère de GeoGebra.

Nous pouvons maintenant graduer notre axe. Et nous commençons par la graduation secondaire. Pour cela, nous allons créer une liste de segments verticaux d’une unité de longueur et centrés sur le vecteur qui nous sert d’axe. Ces segments sont définis par leurs deux extrémités, le paramètre de la séquence (« n ») étant leur abscisse. Le curseur « b », quant à lui, servira d’échelle de la représentation : ce sera le pas de la séquence (plus sa valeur sera grande, plus les graduations seront espacées). La dernière graduation sera positionnée deux unités avant l’extrémité du vecteur (« a-2 »).

La commande est la suivante : Séquence(Segment((n, -0.5), (n, 0.5)), n, 1, a - 2, b)

Maintenant les graduations principales. Le troisième curseur (« c ») indiquera le partage de l’unité. Les segments utilisés pour ces graduations seront un peu plus longs que les précédents et le pas pour la variable qui sert d’abscisse (« m ») est cette fois « c*b » (le produit du nombre de partages de l’unité par l’échelle de la représentation). La commande à utiliser est celle-ci : Séquence(Segment((m, -0.7), (m, 0.7)), m, 1, a - 2, c*b)

On peut ensuite, dans les paramètres de l’objet ainsi créé, changer sa couleur et son épaisseur :

Partage de l’unité en 3

Le plus dur est fait, il ne reste plus qu’à réfléchir à quelques finitions. Je propose d’ajouter ces éléments :

• 4 points (A, B, C et D) qui appartiennent à la graduation secondaire (point sur objet).
• 4 cases à cocher (« BoîteSélection ») pour montrer ou masquer ces points.
• Deux points de coordonnées (1 + 2b*c, 0) et (1 + 3b*c, 0) : ils sont sur les 3e et 4e graduations principales.
• Deux textes attachés à ces deux points : ils affichent les abscisses de deux graduations principales consécutives.
• Un champtexte qui permet de saisir la première de ces deux abscisses à afficher.

Il ne reste plus qu’à tout paramétrer comme on le souhaite et à rédiger une consigne qui sera accompagnée de la capture d’écran :

Déterminer les abscisses des points A, B, C et D. Elles seront données comme la somme d’un nombre entier naturel et d’une fraction plus petite que 1.

  Diagrammes en barres

Je vais donner ici la méthode qui m’a permis de construire les diagrammes en barres de cet exerciseur :

Il y a 3 éléments clés dans la construction du diagramme (je ne détaillerai pas ici les autres éléments qui sont hors du sujet de cet article) :

• Le réseau de segments horizontaux qui servent de graduations ;
• les valeurs qui sont représentées ;
• les bâtons ;

Je choisis de montrer la méthode pour un diagramme représentant les effectifs de 5 modalités différentes. Les effectifs seront compris entre 1 et 20. Il est très facile de changer ces paramètres.

Les graduations ne sont pas forcément indispensables, car on peut très bien utiliser la grille de GeoGebra. Mais leur construction est rapide est le résultat sera plus esthétique. Voici la commande à saisir pour obtenir les 21 segments horizontaux espacés d’une unité :

Séquence(Segment((0, i), (18, i)), i, 0, 20, 1)

Pour construire le diagramme, il faut préalablement définir la liste des 5 effectifs à représenter. Je vais nommer « LE », « pour liste des effectifs », cette liste ; nous l’utiliserons à la prochaine étape. On peut la générer aléatoirement avec la séquence suivante :

LE = Séquence(AléaEntreBornes(1, 20), i ,1 , 5)

Ici, la variable « i » n’est pas utilisée dans l’expression, mais il faut tout de même la préciser. La séquence correspond ici à une boucle for i in range(5): de Python.

Enfin, pour construite les barres du diagramme, j’utilise la commande Polygone() en donnant les coordonnées des 4 sommets de chaque rectangle : leur hauteur correspond à l’élément de la liste « LE » à représenter.

Séquence(Polygone((3i-1,0), (1+3i,0), (1+3i , LE(i)), (3i-1,LE(i))), i, 1, 5)

En masquant la grille et l’axe des abscisses, voici le résultat obtenu (appliquette interactive à manipuler) avec uniquement ces 3 instructions et un bouton que j’explique juste en dessous :

La commande ActualiserConstruction() permet de recalculer les nombres aléatoires et donc d’obtenir un nouveau graphique. Il est pratique de l’insérer dans le script d’un bouton. Et, une nouvelle fois, des captures d’écran ou des exports dans un format d’image permettent de se créer des consignes d’exercices.

 Pour aller plus loin : utilisation de la commande Exécute() avec une séquence

  Des points sur une parabole

Revenons sur un des points importants que j’ai mentionné dans mon premier exemple de création de liste d’objets (points sur une courbe) : « la liste ainsi créée forme un seul et unique objet : il n’est pas possible de masquer certains de ces points seulement ou de changer la couleur de seulement quelques-uns. »

Ce point peut pourtant être contourné. Il est possible, en utilisant la commande Exécute() d’obtenir des points indépendants les uns des autres et même de les nommer. Cependant, cette commande n’est pas simple à utiliser et demande une certaine prise en main. Elle exécute une liste de commandes qui sont saisies sous forme de textes. Une séquence créant bien une liste, ces deux commandes fonctionnent bien ensemble. Comme en début d’article, je ne peux que recommander de se rendre sur le manuel en ligne de GeoGebra sur la page dédiée à cette commande.

Nous revenons donc sur le cas de création de points appartenant à une parabole. Pour les obtenir, nous avions utilisé la commande Séquence((i,i^ 2), i, -3, 3).

Pour utiliser la commande Exécute(), il va falloir passer en texte (en utilisant des guillemets) les parties de l’expression qui ne contiennent pas la variable. Voici ce que ça donne dans notre cas :

Exécute(Séquence("(" i "," i^2 ")", i, -3, 3))

Ça peut paraitre très complexe à la première lecture ! Les parties entre guillemets de cette expression sont considérées comme étant du texte. Cependant, la variable « i » et les calculs faits avec elle ne sont pas du texte : ici, seules les parenthèses (celle des coordonnées du point créé) et la virgule (séparateur des coordonnées) sont entre guillemets.

Nous obtenons ainsi nos sept points indépendants. Mais attention, ces points sont libres et peuvent donc être déplacés.

Il est possible de numéroter les points plutôt que de laisser GeoGebra leur affecter un nom par ordre alphabétique. La commande à utiliser est :

Exécute(Séquence("A_{" i "}=(" i "," i^ 2 ")", i, -3, 3))

La notation « A_« i » » permet de mettre i en indice. Là encore, seules les parties contenant la variable ne sont pas entre guillemets.

On obtient des indices négatifs pour les 3 premiers points : cela peut être facilement corrigé en modifiant la commande : Exécute(Séquence("A_{"(i+3)"}=(" i "," i^ 2 ")", i, -3, 3)), par exemple.

  Une suite définie par récurrence

Une autre utilisation intéressante de l’association des deux commandes Exécute() et Séquence() est le travail sur les suites.

Prenons comme exemple une suite $\left( u_{n}\right) $ définie par son premier terme $u_{0}=-5$ et, pour tout entier naturel $n $, $u_{n+1}=-\frac{1}{2}u_{n}+3$.

Il faut commencer par saisir le premier terme avec la commande u_0 = -5.

La commande qui permet de calculer les 10 termes suivants de la suite est :

Exécute(Séquence("u"(n+1)"= -0.5*u"n"+3", n, 0, 9))

Remarque  : j’ai volontairement omis l’écriture en indice des rangs des termes pour que la commande soit plus compréhensible.

On obtient alors une suite de nombres qui sont visibles dans la fenêtre Algèbre :

Et cette suite reste dynamique : si on modifie la valeur du premier terme, toutes les valeurs sont recalculées. Une nouvelle fois, un curseur peut s’avérer utile si on souhaite faire varier ce premier terme pour observer le comportement de la suite.

Une autre chose utile pourrait être d’avoir tous ces termes de la suite dans une seule liste. La méthode la plus rapide pour récupérer une telle liste est de modifier notre commande initiale pour que les valeurs des termes de la suite soient stockées dans le tableur de GeoGebra.

Le premier terme sera stocké dans la première cellule du tableur par la saisie A1 = 2. Puis dans la séquence, « A » remplace « u » :

Exécute(Séquence("A"(n+1)"= -0.5*A"n"+3", n, 1, 10))

Pour récupérer les valeurs qui sont maintenant dans la première colonne du tableur, on utilise la commande L = Plage(A1, A11). Et si on veut les représenter dans un repère on utilisera la commande Séquence((n,L(n)), n, 1, 11) où « (n,L(n)) » représente les coordonnées des points à représenter. Dans le résultat obtenu ci-dessous (appliquette interactive à manipuler), le curseur permet de faire varier la valeur du premier terme.

 Conclusion

Quand j’ai commencé la rédaction de cet article, je ne pensais pas qu’il serait si long. J’avais dans l’idée de montrer seulement quelques exemples basiques. Mais au fur et à mesure que j’avançais, de nouvelles idées s’imposaient à moi. De fil en aiguille, l’article s’est considérablement étoffé par rapport à mon idée de départ. Et encore, je me suis limité, car les exemples intéressants à développer sont bien plus nombreux. Une petite recherche dans les ressources disponibles sur le site de GeoGebra pourra vous donner des idées.

Je pense tout de même avoir bien dégrossi le travail pour tous ceux et toutes celles qui souhaitent se mettre à la « programmation » avec GeoGebra et qui pourraient avoir besoin de cette commande Séquence().

 Quelques liens utiles

Le manuel de GeoGebra sur github
Le site de la c2it sur la Forge (en cours de construction)
La chaîne YouTube de Mickaël Launay

Quelques travaux d’utilisateurs de GeoGebra qui utilisent des séquences :

• par Christian Mercat ;
• par Jean-Baptiste Etienne ;
• par Patrick Clément ;
• par Juan Carlos Ponce Campuzano ;
• par le GeoGebra Institute of Hong Kong ;
• par Ramaswamy Kodam ;
• par Bill Lombard ;
• par John Golden.