Analyse

Retrouvez toutes les fiches de cours téléchargeables au format pdf en cliquant sur les liens suivants :

• Fiche n° 1 : Algorithme en langage naturel
• Fiche n° 2 : Les variables
• Fiche n° 2 bis : Les listes
• Fiche n° 3 : Les fonctions
• Fiche n° 3 bis : Mathématiques et programmation
• Fiche n° 4 : Les instructions conditionnelles
• Fiche n° 5 : Les boucles bornées
• Fiche n° 6 : Les boucles non bornées

1

Calculer les termes d’une suite ★★☆

→ Voir fiche n° 3 : Les fonctions

On considère la suite $(u_n)$ de premier terme $u_0=3$ et telle que $u_{n+1}=0,5u_n+1$ pour tout $n\in \mathbb{N}$.
On considère les deux fonctions suivantes permettant de calculer $u_n$ avec $n$ donné en paramètre.

1. Compléter la fonction u_niteratif qui calcule $u_n$ itérativement en utilisant la relation de récurrence qui définit $u_n$.

2. Compléter la fonction u_nrecursif qui calcule $u_n$ récursivement, en vous aidant de la relation de récurrence qui définit $u_n$.

3. Expliquer le fonctionnement de chacune de ces fonctions.

def u_niteratif(n):
  u = ...
  k = 0
  while k < = n:
    u = ...
    k = ...
  return u

def u_nrecursif(n):
  if n == 0:
    return ...
  else:
    return ...

2

Suite de Fibonacci ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 5 : Les boucles bornées

La fonction Python ci-après permet de calculer les termes de la suite de Fibonacci définie par la relation de récurrence $u_0=1$, $u_1=1$ et, pour tout entier naturel $n⩾1$, $u_{n+1}=u_n+u_{n-1}$.

1. La fonction suite_fibo ci-après permet de calculer les termes de la suite de Fibonacci. Quel résultat est renvoyé par suite_fibo(6) ?

def suite_fibo(n):
  a = 1
  b = 1
  for i in range(n):
    u = a + b
    b = a
    a = u
  return u

2. Compléter le tableau suivant en indiquant les différentes valeurs prises par les variables $a$, $b$, $i$ et $u$.

3

Théorème de Cesaro ★☆☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 5 : Les boucles bornées

Soit $(u_n{)}_{n⩾1}$ une suite de nombres réels, admettant pour limite un réel $\ell$.
Soit $(S_n{)}_{n⩾1}$ la suite des moyennes des $n$ premiers termes de la suite $(u_n)$.

1. Dans le programme ci-après, quelle est la suite $(u_n)$ utilisée ?


2. Expliquer la définition de la fonction S(n).


3. En utilisant ce programme, conjecturer la limite de la suite $(S_n)$.

from math import sin, sqrt
 
def u(n):
  return 7 - 5*sin(1/n) + 17/n**2
 
def S(n):
  somme = 0
  for i in range(1, n+1):
    somme = somme + u(i)
  return somme/n
 
def premiers_termes(v, n):
  liste = []
  for k in range(1, n+1):
    liste.append(v(k))
  return liste
 
print(premiers_termes(u, 100))
print(premiers_termes(S, 100))

4

Calcul d’approximations ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 3 : Les fonctions

La fonction ci-après permet de calculer une valeur approchée de $\sqrt{2}$ par balayage.

1. Modifier cette fonction pour qu’elle renvoie $\sqrt{3}$ avec une précision de $0,001$.
2. Modifier cette fonction pour qu’elle renvoie $\ln (2)$ avec une précision de $0,001$.
3. Compléter cette fonction pour qu’elle renvoie $\ln (x)$, où $x$ est un nombre strictement supérieur à 1 donné en paramètre, avec une précision de $0,01$.
4. Compléter la fonction précédente pour que la précision puisse être donnée en paramètre par l’utilisateur.

def racine2_balayage():
  compteur = 0
  while compteur*compteur - 2 < 0:
    compteur = compteur + 0.01
  return compteur

5

Calcul du logarithme par dichotomie ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 4 : Les instructions conditionnelles

La fonction suivante permet de calculer le logarithme d’un nombre $x>0$ donné en paramètre à l’aide d'un algorithme de dichotomie.

1. À quel intervalle doit appartenir $x$ pour que la fonction renvoie le résultat souhaité ?


2. Compléter les lignes 9, 11 et 12 pour que l’algorithme fonctionne.

3. Combien d’étapes supplémentaires seront nécessaires à l’algorithme si on choisit $a=-1000$ et $b=1000$ ?

from math import log, exp

def logarithme_dichotomie(x, precision = 0.01):
  a = -100
  b = 100
  milieu = 0
  while abs(a - b) > precision:
    if exp(milieu) - x < 0:
      ...
    else:
      ...
    milieu = ...
    return milieu

print(logarithme_dichotomie(2))

6

Fonction de Riemann ★★☆

→ Voir fiche n° 1 : Algorithme en langage naturel
→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 5 : Les boucles bornées

Dans cet exercice, on s’intéresse aux suites de la forme $(S_n^{\alpha })$ définies, pour tout $\alpha >1$, par :
$S_n^{\alpha }=\frac{1}{1^{\alpha }}+\frac{1}{2^{\alpha }}+\cdots +\frac{1}{n^{\alpha }}=\sum _{k=1}^n\frac{1}{k^{\alpha }}$.
On donne les valeurs suivantes :

• $\underset{n\to +\infty }{\lim }{S}_n^2=\frac{{\pi }^2}{6}$ ;
• $\underset{n\to +\infty }{\lim }{S}_n^4=\frac{{\pi }^4}{90}$ ;
• $\underset{n\to +\infty }{\lim }{S}_n^6=\frac{{\pi }^6}{945}$ ;
• $\underset{n\to +\infty }{\lim }{S}_n^8=\frac{{\pi }^8}{9450}$.

1. Écrire une fonction zeta qui prend en paramètres deux nombres entiers $n$ et $\alpha$ supérieurs ou égaux à $1$ et qui renvoie la valeur de $S_n^{\alpha }$.

2. Tester les limites proposées dans l’énoncé.

3. Conjecturer l’existence, ou non, de $\underset{n\to +\infty }{\lim }{S}_n^1$.

7

Maximum d’une fonction ★★☆

→ Voir fiche n° 2 : Les variables
→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 3 bis : Mathématiques et programmation
→ Voir fiche n° 4 : Les instructions conditionnelles
→ Voir fiche n° 5 : Les boucles bornées

On considère une fonction $f$ continue modélisée sur Python par une fonction f du même nom. On cherche à déterminer « au hasard » une approximation du nombre réel x_max pour lequel le maximum est atteint, sur l’intervalle $[0;1]$.

1. Étudier le code fourni et répondre aux questions suivantes.
a. Quelle fonction est étudiée ?


b. Trouver, par le calcul, le maximum de cette fonction sur $[0;1]$.


c. Pour combien de valeurs de $x$ le programme calcule-t-il $f(x)$ ?


d. Exécuter le programme. Le résultat semble-t-il cohérent avec la question b. ?


2. Quelles modifications peut-on apporter pour obtenir une meilleure approximation ?


3. Modifier le programme pour qu’il permette de trouver une approximation du maximum de $f$ sur un intervalle $[c;d]$.

from math import*
from random import*

def f(x):
  return x*(1 - x)

def cherche_max(fonction):
  x_max = 0
  y_max = fonction(x_max)
  for i in range(100000):
    a = random()
    if fonction(a) > y_max:
      y_max = fonction(a)
      x_max = a
  return x_max

print(cherche_max(f))

8

Calcul d’intégrale : méthode de Monte-Carlo ★☆☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

1. On cherche à connaître une valeur approchée de l’intégrale suivante : ${\int }_1^{2}x(3-x)(3+x)\mathrm{d}x$.
Vérifier que la fonction Python monte_carlo ci-après convient en écrivant print(monte_carlo(fonction, 1, 2, 1000)).

2. La méthode semble-t-elle se rapprocher rapidement de la valeur de l’intégrale lorsque $n$ croît ?

from random import random
 
def fonction(x):
  return x*(3 - x)*(3 + x)
 
def monte_carlo(f, a, b, n):
  somme = 0
  for i in range(n):
    somme = somme + f(a + (b - a)*random())
  return somme/n

9

Méthode des rectangles ★★☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

La méthode des rectangles pour calculer une intégrale est présentée dans l’activité A du chapitre 11. On en propose ici une version différente. On utilise la fonction $x\mapsto x(3-x)(3+x)$ de l’exercice précédent.

1. Créer une fonction Python points ayant comme paramètres deux nombres réels $a$ et $b$ tels $a<b$ et un entier naturel $n$. Cette fonction doit retourner la liste des $n+1$ nombres de la forme $a+\frac{b-a}{n}k$ , où $k$ est un nombre entier variant avec un pas de $1$ dans l’intervalle $[0;n]$.
Ainsi points(1, 2, 5) doit renvoyer [1.0, 1.2, 1.4, 1.6, 1.8, 2.0].

2. Créer une fonction images ayant comme paramètres le nom d’une fonction numérique et une liste de nombres. Cette fonction doit renvoyer la liste des images de ces nombres par la fonction.
Ainsi images(f, [0, 1, 2, 3]) doit renvoyer [0, 8, 10, 0] lorsque f est la fonction définie dans l’énoncé.

3. Expliquer alors pourquoi la fonction rectangles ci-après correspond à la méthode des rectangles. On précisera en particulier le rôle de chacune des variables.


4. Peut-on imaginer une modification du programme qui donnerait une autre version de la méthode des rectangles en considérant des rectangles différents ?


5. Ces deux versions permettent-elles une meilleure approximation que la méthode de Monte Carlo donnée dans l’exercice précédent ?

def rectangles(f, a, b, n):
    x = points(a, b, n)
    fx = images(f, x)
    p = n*[(b-a)/n]
    p = p + [0]
    integrale = 0
    for k in range(n+1):
    integrale = integrale + p[k]*fx[k]
    return integrale
  

10

Méthode des trapèzes ★★★

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

L’exercice précédent présente la méthode des rectangles. En considérant non pas des rectangles, mais des trapèzes, on améliore grandement l’efficacité de la méthode précédente. Cet exercice se propose de montrer que sa programmation est très voisine de celle de la méthode des rectangles.

1. Rappeler la formule donnant l’aire d’un trapèze.


2. Comparer l'efficacité de la fonction qui permet de mettre en œuvre la méthode des rectangles avec celle donnée ci‑dessous, qui correspond à la méthode des trapèzes.

def trapezes(f, a, b, n):
  x = points(a, b, n)
  fx = images(f, x)
  p = (n - 1)*[(b - a)/n]
  p = [0.5*(b - a)/n] + p + [0.5*(b - a)/n]
  integrale = 0
  for k in range(n + 1):
    integrale = integrale + p[k]*fx[k]
  return integrale

11

Méthode d’Euler explicite ★★☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 6 : Les boucles non-bornées

L’exercice du chapitre 10 propose la méthode d’Euler pour résoudre l’équation différentielle $(E)$ $y^{\prime }=y$ telle que $y(0)=1$.
Ici, l’objectif est d’utiliser la méthode d’Euler pour déterminer une approximation de la solution $y$ sur $[0;1]$ par deux listes X et Y, contenant respectivement une liste croissante de nombres compris entre $0$ et $1$ et leurs images respectives par $y$.
On admet que, lorsque $h$ est très proche de $0$, $\frac{f(x_0+h)-f(x_0)}{h}$ est une bonne approximation de $f^{\prime }(x_0)$.

1. On souhaite que la liste X soit la liste des termes successifs d’une suite arithmétique de premier terme $0$ et de raison $h$ et qui sont inférieurs ou égaux à $1$. Ainsi, si $h=0,4$, X doit être [0, 0.4, 0.8].
Compléter la ligne 11 du programme ci-après.

2. En utilisant l’approximation proposée et l’équation $(E)$, montrer que $y(x+h)\approx (1+h)y(x)$.
En déduire comment compléter la ligne 12.


3. Utiliser la fonction graphe fournie pour représenter une approximation de la solution.

import matplotlib.pyplot as plt
 
def euler_explicite(h):
  X = []
  Y = []
  x = 0
  y = 1
  while (x <= 1):
    X.append(x)
    Y.append(y)
    x = ...
    y = ...
  return [X,Y] 
 
def graphe(x,y):
  plt.plot(x,y)
  plt.show()

12

Méthode d’Euler implicite ★★★

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 6 : Les boucles non-bornées

La méthode proposée dans l’exercice précédent est la méthode d’Euler explicite. Elle permet d’obtenir une approximation de $f(x+h)$ directement à partir de $f(x)$ et $h$. On rappelle que l’on considère l’équation $(E)$ $y^{\prime }=y$ telle que $y(0)=1$.
Une version un peu améliorée, la méthode d’Euler implicite, est proposée ici.
Au lieu d’utiliser l’approximation $f^{\prime }(x)\approx \frac{f(x+h)-f(x)}{h}$, on utilise $f^{\prime }(x+h)\approx \frac{f(x+h)-f(x)}{h}$.

1. Déterminer alors une expression de $y(x+h)$ en fonction de $y(x)$.


2. Modifier la fonction euler_explicite de l’exercice précédent, en prenant en compte la nouvelle expression de $y(x+h)$.

13

Formule de Stirling ★☆☆

→ Voir fiche n° 3 : Les fonctions

Soient $(u_n)$ et $(v_n)$ les suites définies pour tout entier naturel $n$ par $u_n=n!$ et $v_n=\sqrt{2\pi n}{\left(\frac{n}{\mathrm{e}}\right)}^n$.
À l’aide d’une fonction écrite en Python, conjecturer la valeur de $\underset{n\to +\infty }{\lim }\frac{v_n}{u_n}$.
On pourra créer une fonction factorielle ou bien utiliser celle du module math de Python.

14

Formule de Taylor ★☆☆

→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 5 : Les boucles bornées

On souhaite trouver une bonne approximation de la fonction exponentielle au voisinage de $0$.

1. Rappeler l’équation réduite de la tangente à la représentation graphique de la fonction exponentielle, au point d’abscisse $0$, dans un repère orthogonal. Il s’agit ici d’une approximation linéaire.


2. Expliquer le script Python ci-après puis le tester pour représenter graphiquement la fonction exponentielle et sa tangente au point d’abscisse $0$ en appelant trace(100,1).

3. Pour des fonctions suffisamment régulières, il est possible d’obtenir des approximations de meilleure qualité. Par exemple, pour la fonction exponentielle, la fonction $f_n$ définie par : $f_n(x)=\sum _{k=0}^n\frac{x^k}{k!},$ où $n$ est un nombre entier naturel, permet d’obtenir une famille de polynômes, de plus en plus proches de la fonction exponentielle, au voisinage de $0$.

a. Déterminer l’expression de $f_1(x)$. Que retrouve-t-on ?


b. Écrire explicitement les quatre termes de $f_3(x)$.


4. Modifier la fonction Python DLexp(x,n) qui prend en paramètres un réel $x$ et un entier naturel $n$ et renvoie $f_n(x)$.

5. Observer comment les fonctions $f_n$ approchent la fonction exponentielle en testant différentes valeurs de $n$.

import matplotlib.pyplot as plt # on charge la fonction pyplot de matplotlib
from math import *
from numpy import linspace
 
def DLexp(x, n):
  return 1 + x
 
def trace(N,n):
  xs = linspace(-1, 1, N)
  ys = [exp(x) for x in xs]
  ya = [DLexp(x, n) for x in xs]
  plt.plot(xs, ys)
  plt.plot(xs, ya)
  plt.savefig("figure.png")

15

Maxima locaux d’une fonction ★★☆

→ Voir fiche n° 2 bis : Les listes
→ Voir fiche n° 3 : Les fonctions
→ Voir fiche n° 4 : Les instructions conditionnelles
→ Voir fiche n° 5 : Les boucles bornées

1. Construire une fonction maximum qui prend en paramètre une liste et renvoie le plus grand élément de cette liste. On n’utilisera pas la fonction max déjà définie en Python.

2. Une fonction $f$ est décrite par la donnée de deux listes x et y, où les éléments de y sont les images des élément de x par $f$.
Construire une fonction maxima_locaux en Python qui prend en entrée la liste y et renvoie la liste des maxima locaux. À titre d’exemple, on pourra utiliser la fonction $f:x\mapsto \frac{\sin (x)}{\sqrt{x}}$ définie sur ${\mathbb{R}}^{\ast }$. On la prolonge par continuité en posant $f(0)=0$. Le début du programme est indiqué ci-dessous.

from math import sqrt, sin
 
def sinus_amorti(x):
  if (x == 0):
    return 0
  else:
    return sin(x)/sqrt(x)

def fonction2liste(fonction, a, b, n):
  x = []
  y = []
  for k in range(n + 1):
    x_i = a + (b - a)*k/n
    x.append(x_i)
    y.append(fonction(x_i))
  return [x, y]

def maxima_locaux(liste):
  ...
  return ml
 
out = fonction2liste(sinus_amorti, 0, 20, 1000)
maxloc = maxima_locaux(out[1])
print(maxloc)

16

Intégrale de Gauss ★★☆

→ Voir fiche n° 3 : Les fonctions

Un résultat mathématique très important pour les statistiques dit que : ${\int }_{-\infty }^{+\infty }{\mathrm{e}}^{-x^2}\mathrm{d}x=\sqrt{\pi }$. En utilisant Python et éventuellement des fonctions déjà construites dans les exercices précédents, retrouver ce résultat.