→

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 ...

→

Voir fiche n° 2 : Les variables

→

Voir fiche n° 5 : Les boucles bornées

Soit (u_n)_{n\geqslant 1} une suite de nombres réels, admettant pour limite un réel \ell.
Soit (S_n)_{n\geqslant 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))

→

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

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

Dans cet exercice, on s'intéresse aux suites de la forme (S^{\alpha}_n) définies, pour tout \alpha >1, par :

On donne les valeurs suivantes :

• \underset{n \rightarrow +\infty}{ \lim}S^{2}_n=\dfrac{\pi^2}{6} ;
• \underset{n \rightarrow +\infty}{ \lim}S^{4}_n=\dfrac{\pi^4}{90} ;
• \underset{n \rightarrow +\infty}{ \lim}S^{6}_n=\dfrac{\pi^6}{945} ;
• \underset{n \rightarrow +\infty}{ \lim}S^{8}_n=\dfrac{\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^{\alpha}_n.

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

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

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

→

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 : \displaystyle \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

1. Créer une fonction Python points ayant comme paramètres deux nombres réels a et b tels a et un entier naturel n. Cette fonction doit retourner la liste des n+1 nombres de la forme a+\dfrac{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
  

→

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

→

Voir fiche n° 3 : Les fonctions

→

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

L'exercice

123

du chapitre 10 propose la méthode d'Euler pour résoudre l'équation différentielle (E) y' = 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, \dfrac{f(x_0+h)-f(x_0)}{h} est une bonne approximation de f'(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()

→

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' = 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'(x)\approx \dfrac{f(x+h)-f(x)}{h}, on utilise f'(x+h)\approx \dfrac{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).

→

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 \displaystyle\lim_{n \to +\infty} \frac{v_n}{u_n}.
On pourra créer une fonction factorielle ou bien utiliser celle du module math de Python.

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)= \displaystyle \sum_{k=0}^{n}\dfrac{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")

→

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 \colon x \mapsto \frac{\sin(x)}{\sqrt{x}} définie sur \mathbb{R}^*. 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)

→

Voir fiche n° 3 : Les fonctions

Un résultat mathématique très important pour les statistiques dit que : \displaystyle \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.