Cette méthode, classique, consiste, à partir d’un intervalle [a ; b] dans lequel on sait trouver $\sqrt{2}$, à calculer x², pour x allant de a à b avec un pas de h, « Tant Que » x² < 2 est vérifiée (On utilisera pour cela un While.). La fonction carré étant croissante, dès que x² > 2 on arrête l’algorithme et on obtient un encadrement de longueur h de $\sqrt{2}$ : $x – h ≤ \sqrt{2} < x$.
Il faut déterminer a et b, les bornes de l’intervalle dans lequel on va appliquer le balayage. On prendra a = 1 et b = 2 en effet 1<2<4 donc $1 < \sqrt{2} < 2$.

Fonction qui calcule cet encadrement, renvoyé dans un tuple, en fonction du nombre n de décimales souhaitées :
Cet algorithme détermine par balayage un encadrement de racine de 2 d’amplitude 10^(-n).

Utilisation : Compiler le fichier puis dans la console taper balayage(9) puis « Entrer » :

Le round permet ici de corriger quelques erreurs d’affichage des flottants [1].
Il est à noter que cet algorithme est très long à donner une réponse si n>=9.
On peut donc chercher à l’optimiser, par exemple en utilisant une boucle for qui va faire la même chose que le programme précédent mais pour h allant de 10^-1 à 10^-n en réduisant l’intervalle [a ; b] à chaque boucle.
C’est beaucoup plus rapide, jusqu’à n=16 où ça bogue, parce que les flottants (décimaux) ne sont affichés qu’avec 16 chiffres après la virgule.

Les deux programmes précédents dans Sofuspy :
A l’ouverture de la page, vous pouvez exécuter le programme en blocs en cliquant sur « Exécuter » au-dessus des blocs, entrez une valeur de n<=6 parce qu’ils ne fonctionnent pas au-delà de n=6 car le nombre d’itérations est limité à 1000000. Cette limitation peut être levée en demandant à SofusPy la traduction automatique en Python (en cliquant sur "Traduire"), puis en exécutant le programme ainsi obtenu avec l’interpréteur Python de SofusPy (En cliquant sur "Exécuter" au-dessus du code Python).
balayage1
balayage2

On ne va bien sûr pas utiliser les opérations de base Python :
–  % reste de division entière (17 % 3 donne 2)
– // quotient de division entière (17 // 3 donne 5)
il n’y aurait alors aucun intérêt à parler de cet algorithme.
On va bien sûr utiliser le théorème de la division euclidienne :
Il existe un unique couple $(q, r)\in \mathbb{N}\times\mathbb{N}$ tel que : $a = bq + r, 0 \leq r < b $.
On peut donc programmer le calcul de tous les multiples de $b$ inférieurs à $a$ et voir si l’on atteint $a$.
Nous faisons le choix de renvoyer en résultat un booléen pour indiquer si la réponse à la question que l’on pose à la fonction est vraie ou fausse.
Cet algorithme détermine si un entier naturel $a$ est multiple d’un entier naturel $b$.
$n$ sert à compter le nombre de $b$ dans $m$.

Utilisation : Compiler le programme et taper dans la console

On n’utilisera pas non plus ici les opérations de base Python % et //.
On peut donc programmer le calcul de tous les multiples de $b$ inférieurs à $a$ comme dans l’algorithme précédent, avec des modifications mineures.

Avec Python :
La fonction combien_b_dans_a détermine le plus grand multiple de $b$ inférieur ou égal à $a$.
$n$ sert à compter le nombre de $b$ dans $m$.

Utilisation : Compiler le programme et taper dans la console

La fonction communique_combien_b_dans_a annonce le résultat, elle peut être occultée. Si elle est utilisée, elle nécessite la fonction combien_b_dans_a qu’elle appelle dans son code.

Utilisation : Compiler le programme et taper dans la console

On va ici s’autoriser à utiliser l’opération n%i qui donne le reste de la division euclidienne de $n$ par $i$. On utilisera aussi une liste « diviseurs » qui contiendra tous les diviseurs de $n$ (la méthode append permet d’ajouter un élément à une liste, len(liste) renvoie la longueur de liste).

Si la liste des diviseurs est de longueur 2 c’est qu’elle contient 1 et $n$, donc que $n$ est premier.

Utilisation : Compiler le programme et taper dans la console

On pourra diviser le temps de calcul par 2 avec le code suivant :

En effet, le plus grand diviseur de $n$, autre que $n$, ne peut pas être plus grand que $\frac n 2$.

L’énoncé ressemble beaucoup à « Pour des entiers a et b donnés, déterminer le plus grand multiple de $b$ inférieur ou égal à $a$. », on reprend donc ce script en l’adaptant au nouveau problème :

Le code Python pour $b^n \leq a$ :

Utilisation :

La fonction communique_puissance annonce le résultat, elle peut être occultée. Si elle est utilisée, elle nécessite la fonction puissance qu’elle appelle dans son code.

Utilisation : Compiler le programme et taper dans la console

Et avec une toute petite modification, le code Python pour $b^n \geq a$ :

Utilisation :

On va utiliser le fait que trois points sont alignés si ils ont la même abscisse, ou si ils ont la même ordonnée, ou si les coefficients directeurs de deux des droites qu’ils forment sont égaux. Comme le calcul des coefficients directeurs fait appel à un quotient, il faudra prendre la précaution d’éviter la division par 0.

Pour cet algorithme, nous avons fait le choix d’une fonction qui a en paramètres les noms des points suivis de leurs coordonnées, et qui retourne une phrase qui donne l’équation de la droite lorsque les points sont alignés, d’autres choix peuvent être faits. Cette phrase est une concaténation de chaînes de caractères, ceci se fait tout simplement avec le signe « + », les nombres sont transformés en chaînes de caractères à l’aide de la fonction str().
Ce programme détermine si trois points dont vous allez donner le nom et les coordonnées, sont alignés :
– Ne pas tester en même temps x_A==x_B et x_A==x_C permet d’éviter la division par 0 dans le calcul de m1, le coefficient directeur de (AB)
– m2 est le coefficient directeur de (AC)
– p est l’ordonnée à l’origine de (AB)

Utilisation :

Si l’on veut juste savoir si les points sont alignés ou pas :

Utilisation :

A noter que l’on utilise round pour éviter que le test ne fonctionne pas à cause des flottants alors que m1==m2, voir ci-dessous :

Pour cet algorithme, nous avons fait le choix, dans un premier temps, d’une fonction qui a en paramètres les coordonnées des deux points, et qui retourne une phrase qui donne l’équation réduite de la droite, d’autres choix peuvent être faits. Cette phrase est une concaténation de chaînes de caractères, ceci se fait tout simplement avec le signe « + », les nombres sont transformés en chaînes de caractères à l’aide de la fonction str().
Calcul de l’équation réduite d’une droite à partir des coordonnées de deux de ses points donnés sous la forme de couples (tuples).

Utilisation :

Puisqu’il y a dans les nouveaux programmes de seconde :
– Équation de droite : équation cartésienne, équation réduite.
On peut proposer que la fonction renvoie une équation cartésienne de la droite (ou plus exactement ses coefficients) dans un tuple.
On pourra demander à l’élève de démontrer que si $M(x ; y) \in (AB)$, la colinéarité des vecteurs $\overrightarrow{AB}$ et $\overrightarrow{AM}$ mène à l’équation $(y_A-y_B)x + (x_B-x_A)y+x_A(y_B-y_A)+y_A(x_A-x_B)=0$ :
Calcul d’une équation cartésienne d’une droite à partir des coordonnées de deux de ses points donnés sous forme de couples (tuples).
Pour une équation cartésienne ax + by + c = 0, le programme renvoie (a,b,c).

Utilisation :

Nous commencerons par une fonction dont on sait qu’elle est croissante puis décroissante sur un intervalle [a ; b], donc qu’elle admet un maximum sur cet intervalle.
Nous procéderons d’abord par balayage :

Utilisation :

A noter que Python montre ses limites à partir de n=8, la réponse [0.6666666598, 0.6666666599] est fausse puisque 2/3 n’appartient pas à cet intervalle ...

Par dichotomie, il y a un problème du fait que l’on ne sait pas dans quel intervalle se trouve le maximum : les données de f(a), f(m) et f(b) ne permettent pas de déterminer si le minimum est dans [a ; m] ou dans [m ; b]. Les deux cas sont possibles.

Plutôt que de couper l’intervalle en deux, nous allons le couper en trois, en posant $m = \frac{b -a}{3}$, $c = a + m$ et $d = b - m$.
On a alors a < c < d < b et l’on peut procéder par disjonction des cas, en notant $x_0$ l’abscisse du sommet :
– Si $a < x_0 <= c$, alors $f(c) > f(d)$.
– Si $c <= x_0 <= d$, alors $f(c) >= f(d)$ ou $f(c) <= f(d)$.
– Si $d <= x_0 <= b$, alors $f(c) < f(d)$.
L’on peut résumer cela en :
– Si $f(c) <= f(d)$ alors $x_0 \in [c ; b]$
– Si $f(c) >= f(d)$ alors $x_0 \in [a ; d]$
D’où l’algorithme suivant :

Utilisation :

Où l’on constate les mêmes problèmes que dans le script précédent.

Avec une fonction dont on sait qu’elle est décroissante puis croissante sur un intervalle [a ; b], donc qu’elle admet un minimum sur cet intervalle.

Le code Python pour approcher le minimum par balayage :

Utilisation :

Et par trichotomie :
- On entre l’expression de la fonction dans f(x)
– n est le nombre de chiffres après la virgule souhaités
– e est la précision souhaitée
– a est la Borne inférieure de l’intervalle dans lequel le maximum a été repéré
– b est la Borne supérieure de l’intervalle dans lequel le maximum a été repéré

Utilisation :

Ici, on veut approcher une fonction continue sur un intervalle [a ; b] par n segments dont les abscisses des extrémités sont distantes de (b-a)/n :

Utilisation :

Au lieu de proposer un programme de calcul basique que l’on trouve dans les manuels scolaires, intéressons-nous à un programme de calcul donné par un « magicien » dans une émission de télévision :

Utilisation :

On peut alors conjecturer que le nombre obtenu est toujours égal à 9 fois le chiffre des dizaines, ou plus généralement à un multiple de 9, le démontrer, puis démasquer le « truc » du « magicien ».

On sait qu’une fonction f est croissante sur un intervalle [a ; b] si :
pour tous x et y de [a ; b], si x < y alors f(x) < f(y).
On sait qu’une fonction f est décroissante sur un intervalle [a ; b] si :
pour tous x et y de [a ; b], si x < y alors f(x) > f(y).

On peut donc imaginer de tester « pour tous » x et y de [a ; b], si f(x) < f(y), évidemment ici le "pour tous" va être remplacé par "un certain nombre de" ...
On peut alors avoir l’idée de mettre un "m" quand f(x) < f(y) (ça "monte") et un "d" quand f(x) > f(y) (ça « descend »), comme dans le script suivant :

Utilisation :

Ce qui peut permettre de conjecturer que f est croissante puis décroissante puis croissante sur [-5 ; 5] ...
On peut affiner la conjecture en modifiant l’algorithme de manière à afficher les abscisses, on peut ainsi insérer avant le test if y1<y2 : :

On obtient alors :
[-4.0, ’m’, -3.0, ’m’, -2.0, ’m’, -1.0, ’d’, 0.0, ’d’, 1.0, ’d’, 2.0, ’d’, 3.0, ’m’, 4.0, ’m’, 5.0, ’m’] ce qui peut permettre de conjecturer que f est croissante puis décroissante puis croissante, le changement de sens de variation se faisant entre -3 et -1 puis entre 1 et 3 (Attention ici à ne pas croire que ces changements se passent dans [-2 ; -1] et dans [2 ; 3], cela n’est pas vrai en général, nous vous laissons y réfléchir avec ces deux images ...).

On peut ensuite affiner :
tableau = [-2.8, ’m’, -2.6, ’m’, -2.4, ’m’, -2.27, ’m’, -2.0, ’m’, -1.8, ’m’, -1.6, ’m’, -1.4, ’d’, -1.2, ’d’, -1.0, ’d’]
tableau = [-1.76, ’m’, -1.72, ’m’, -1.68, ’m’, -1.64, ’d’, -1.6, ’d’, -1.56, ’d’, -1.52, ’d’, -1.48, ’d’, -1.44, ’d’, -1.4, ’d’]
tableau = [-1.712, ’m’, -1.704, ’m’, -1.696, ’m’, -1.688, ’d’, -1.68, ’d’, -1.672, ’d’, -1.664, ’d’, -1.656, ’d’, -1.648, ’d’, -1.64, ’d’]
pour en déduire que le premier changement de sens de variation se passe dans [-1.704 ; -1.688], en réalité en $\frac{2-\sqrt{148}}{6}\approx-1.694$.

On a besoin de calculer une racine carrée pour obtenir l’écart-type, ceci n’est pas possible dans Python sauf à importer cette fonction depuis un fichier math.py qui contient de nombreuses fonctions mathématiques, cela se fait à l’aide de la ligne suivante : from math import sqrt

Après avoir compilé le code, on peut taper dans la console :

On peut compléter ce qui précède avec l’ensemble des fonctions qui donnent toutes les caractéristiques d’une série de données ’a 1 variable :

Après avoir compilé le code, on peut taper dans la console :

On retrouve bien :

• Le minimum : 6
• Le premier quartile : 15
• La médiane : 41
• Le troisième quartile : 43
• Le maximum : 49

Utilisation :

On peut calculer la fréquence dans la console comme ci-dessus ou changer la dernière ligne du programme :

ou pour récupérer nombre et fréquence :

En statistiques, la loi des grands nombres exprime le fait que les caractéristiques d’un échantillon aléatoire se rapprochent des caractéristiques statistiques de la population lorsque la taille de l’échantillon augmente. Autrement dit la fréquence de succès d’un événement sur l’échantillon s’approche de la probabilité de cet événement sur la population.
Nous choisissons d’illustrer cela avec un jeu de dé :
On lance un dé à 6 faces non truqué.
– Si c’est 1 qui sort, on gagne 1€.
– Si c’est 2, 3 ou 4 qui sort, on gagne 2€.
– Sinon, on gagne 4€.
L’espérance de gain à ce jeu est donc de $\frac{1 \times 1 + 3\times 2 + 2\times 4}{6} = 2,5€$.
On utilisera deux fonctions :
– Une fonction expérience() qui simule un jeu.
– Une fonction evolutionMoyenne(experience,nExperiences) qui va jouer nExperiences fois le jeu, en calculant la moyenne à chaque nouveau jeu et en représentant graphiquement l’évolution de cette moyenne à l’aide de la librairie matplotlib :

Utilisation :