Regards croisés sur l'algorithmique et la programmation (1) - Les nouvelles technologies pour l'enseignement des mathématiques

Mathématice, intégration des Tice dans l'enseignement des mathématiques

À propos de MathémaTICE Mentions légales Comment contribuer ? Appels à contribution Fonctionnement du moteur de recherche

Sommaire > N°36 - septembre 2013 > Regards croisés sur l’algorithmique et la (...)

Regards croisés sur l’algorithmique et la programmation (1)

Moteur de recherche

Mis en ligne le 12 juillet 2013, par Alain Busser, Guillaume Connan, Hubert Raymondaud, Pierre-Marc Mazat, Stéphan Manganelli

Il y a quelques semaines, Hubert Raymondaud a suggéré la création d’une rubrique régulière dans MathémaTICE, consacrée à l’algorithmique et à la programmation. Plusieurs auteurs, familiers de ces démarches, ont accepté de l’alimenter au fil du temps.

Après de nombreux échanges sur la forme que prendrait cette rubrique, nous sommes convenus de l’intituler "Regards croisés sur l’algorithmique et la programmation".

La règle est simple :

Un des participants (à tour de rôle) propose un sujet.
Chaque participant connaît les contributions de ses collègues et a toute liberté de traiter le sujet, avec les développements théoriques et les langages qu’il juge adaptés.
Les contributions apparaissent par ordre alphabétique.

Le lecteur découvrira, en les lisant, les multiples manières de décliner cette démarche qui continue d’en angoisser beaucoup, à l’idée de l’enseigner. MathémaTICE espère ainsi aider les collègues à mieux appréhender les difficultés inhérentes à cette relative nouveauté.

Hubert Raymondaud a proposé pour cette première rubrique, de traiter un exercice du baccalauréat S de Polynésie 2013.

Voici le regard de nos collègues sur ce problème.

Vos remarques, suggestions et critiques nous aideront à améliorer la forme et le fond de cette rubrique : mathematice@sesamath.net )

G.Kuntz

Cet article peut être librement diffusé et son contenu réutilisé pour une utilisation non commerciale (contacter l’auteur pour une utilisation commerciale) suivant la licence CC-by-nc-sa (http://creativecommons.org/licenses/by-nc-sa/3.0/fr/legalcode)

Retour au sommaire

Le sujet traité dans cet article est l’exercice 1 du document que voici :


Sujet S Polynésie 2013

Il porte sur la méthode des rectangles, et chacun des auteurs de cet article a trouvé des prolongements dans différentes directions.

Le regard d’Alain Busser

Avec le langage de programmation CoffeeScript qui ressemble à Python mais en ligne, et qui est un langage fonctionnel, l’algorithme du sujet de bac est implémenté de façon à la fois concise et naturelle ;
ceci est fait dans CaRMetal ce qui permet de dessiner les rectangles et de représenter graphiquement la suite des valeurs approchées ;
De par sa ressemblance avec Python, CoffeeScript permet de réinvestir sans gros effort les exemples de cet ouvrage consacré à Python et qui est une mine de ressources. Du même auteur, cet autre ouvrage

Pour tester CoffeeScript en ligne

Pour commencer, on entre la fonction qui ici ne s'appellera pas f mais laFonction puisqu'on peut très bien recommencer l'exercice avec d'autres fonctions (du moment qu'on sait calculer leur intégrale, du moins pour l'étape finale). Pour vérifier que cette fonction est la bonne (qu'on n'a pas fait d'erreur d'algèbre en l'entrant), on affiche un tableau de valeurs de celle-ci:

laFonction = (x) -> (x+2)*Math.exp -x alert ((laFonction k/4).toFixed 3 for k in [0...4])

Remarque: Le cadre ci-dessus est interactif, et on peut modifier l'algorithme à sa guise pour tester le résultat en cliquant sur le bouton ci-dessus.

Pour calculer la somme des 4 aires de rectangles, on fait une boucle dans laquelle on additionne les aires des rectangles, pour le rectangle 0 jusqu'au rectangle 3. On fait cela pour une fonction f quelconque, et la lettre "S" à la fin de l'algorithme signifie que la valeur retournée par l'algorithme est S:

laFonction = (x) -> (x+2)*Math.exp -x sommePour = (f) -> S = 0 for k in [0..3] S += 1/4*f(k/4) S alert sommePour laFonction

Pour la question suivante, on veut que le nombre R de rectangles soit entré comme variable supplémentaire. On peut le faire ainsi:

laFonction = (x) -> (x+2)*Math.exp -x sommePour = (f,N) -> S = 0 for k in [0...N] S += 1/N*f(k/N) S alert sommePour laFonction, 4

Pour chercher à partir de combien de rectangles on a l'intégrale à ε près, on peut enrichir un peu ce qui a déjà été fait:

Calculer une primitive appelée laPrimitiveEn afin que l'image de 1 par cette primitive s'appelle laPrimitiveEn 1
obtenir la valeur la plus précise possible de l'intégrale en calculant la différence entre les images de 1 et de 0 par cette primitive: ∫₀¹ƒ(x) dx=F(1)-F(0)
demander, avec prompt, d'entrer le seuil;
initialiser le nombre de rectangles à 1
si le seuil est compris entre 0,0001 et 1,
- jusqu'à ce que la différence entre la somme des aires des rectangles et l'intégrale soit inférieure au seuil, incrémenter le nombre de rectangles
- afficher le nombre de rectangles qui a été nécessaire

laFonction = (x) -> (x+2)*Math.exp -x laPrimitiveEn = (x) -> (-x-3)*Math.exp -x lIntegrale = (laPrimitiveEn 1) - laPrimitiveEn 0 seuil = prompt "Entrer un seuil entre 0,0001 et 1" sommePour = (f, N) -> S = 0 for k in [0...N] S += 1/N*f(k/N) S nombreDeRectangles = 1 if 0.0001 < seuil < 1 until (sommePour laFonction, nombreDeRectangles)-lIntegrale < seuil nombreDeRectangles += 1 alert "pour avoir l'intégrale à #{seuil} près, il faut au moins #{nombreDeRectangles} rectangles"

Comme l'algorithme devient rédhibitoirement long à tester pour un seuil trop petit, et qu'il ne présente pas d'intérêt avec moins d'un rectangle, on effectue un double test sur le seuil.

l’article en pdf	son source en odt	les figures (CaRMetal)

bonus : un interpréteur CoffeeScript en ligne

(utilitaire en cours d’élaboration par Alain Busser et Florian Tobé)

Autre contribution : Avec le langage MathsOntologie qui lui aussi permet de décrire les algorithmes avec une syntaxe assez naturelle :

l’article en pdf	son source en odt

Remarque

Le principe de l’exercice est basé sur deux constatations :

si f_n tend vers f alors l’intégrale de f_n (qui est une suite numérique) tend vers l’intégrale de f ;
les approximations de f par des fonctions en escalier à n marches, constituent une telle suite de fonctions.

Formaliser mathématiquement ces remarques heuristiques, dépasse largement le programme de Terminale...

Voir aussi

L’exercice traité par Guillaume Connan

Étude mathématique de la méthode des rectangles. Estimation de l’erreur abordable en Terminale ;
Rapide étude du problème avec XCAS en calcul formel ;
Traitement du sujet avec XCAS, Python, Sage, Haskell ;
Étude de la précision. Problème du traitement des flottants sur machine ;
Illustrations graphiques avec XCAS et Python.

$polynesie_sesamath.tex$

Article au format PDF Article au format TeX

Tir à LARP de Stephan Manganelli


Stephan Manganelli

Voici la procédure qui permet de tirer le meilleur parti de ces documents, sous Windows :

Téléchargez gratuitement et installez LARP sur votre ordinateur : http://www.marcolavoie.ca/larp/fr/d...
Dézippez le fichier .zip
Double-cliquez alors sur les différents fichiers LARP obtenus : les organigrammes apparaissent clairement et complètement, et l’on peut exécuter les programmes.

L’apport de Pierre-Marc Mazat

Pierre-Marc implémente son algorithme en CaRScript (dans le module JavaScript de CaRMetal).


Pierre-Marc Mazat

Extraire le contenu de l’archive puis ouvrir le fichier .html

Les solutions d’Hubert Raymondaud

La première page de mon document présente l’esprit, les thématiques et les outils qui guideront mes propositions d’activités.
Je propose la mise en œuvre mot à mot de l’algorithme de l’énoncé puis huit prolongements concernant l’intégration, les petite et grande somme de Darboux (l’énoncé concerne la grande somme de Darboux) et comment les utiliser pour faire de l’intégration numérique.

Le premier prolongement concerne l’utilisation des liste pour remplacer les boucles pour.
Le deuxième fournit un algorithme permettant de tracer les rectangles sur le graphique représentatif de la fonction sur l’intervalle concerné.
Dans le troisième, je montre comment prolonger l’algorithme pour calculer la petite somme de Darboux, dans le cas de la fonction de l’énoncé, positive, strictement croissante entre 0 et 1.
Le quatrième montre comment atteindre une certaine précision pour le calcul de l’intégrale.
Le cinquième aborde le prolongement pour un intervalle [a ; b] sur lequel la fonction est positive et strictement croissante.
Les sixième septième et huitième prolongements abordent l’adaptation de l’algorithme à une fonction (intégrable au sens de Riemann) positive sur un intervalle [a ; b]. Il faut tenir compte du fait que la fonction n’est plus forcément monotone. Il faut donc que l’algorithme trouve le minimum et le maximum sur chacun des intervalles
déterminés par la subdivision choisie.