Chargement de l'audio en cours
Plus

Plus

Analyse
Page numérique




Analyse





1
Calculer les termes d’une suite ★★

Voir fiche n° 3 : Les fonctions

On considère la suite de premier terme et telle que pour tout .
On considère les deux fonctions suivantes permettant de calculer avec donné en paramètre.

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

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

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 la correction

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 , et, pour tout entier naturel , .

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

Ligne 2
Ligne 3
Premier passage dans la boucle
Deuxième passage dans la boucle
Troisième passage dans la boucle
Quatrième passage dans la boucle
Cinquième passage dans la boucle
Sixième passage dans la boucle
Voir la correction

3
Théorème de Cesaro
☆☆

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


Soit une suite de nombres réels, admettant pour limite un réel .
Soit la suite des moyennes des premiers termes de la suite .

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


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


3. En utilisant ce programme, conjecturer la limite de la suite .


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 la correction

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

1. Modifier cette fonction pour qu’elle renvoie avec une précision de .
2. Modifier cette fonction pour qu’elle renvoie avec une précision de .
3. Compléter cette fonction pour qu’elle renvoie , où est un nombre strictement supérieur à 1 donné en paramètre, avec une précision de .
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 donné en paramètre à l’aide d'un algorithme de dichotomie.

1. À quel intervalle doit appartenir 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 et ?


Remarque
Dans les paramètres de la fonction, on a écrit precision=0.01. Cela signifie que le paramètre precision est optionnel. S’il n'est pas fourni par l'utilisateur, il prendra automatiquement la valeur .


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))
Voir la correction

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 définies, pour tout , par :
.

On donne les valeurs suivantes :
  • ;
  • ;
  • ;
  • .

1. Écrire une fonction zeta qui prend en paramètres deux nombres entiers et supérieurs ou égaux à et qui renvoie la valeur de .

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

3. Conjecturer l’existence, ou non, de .



Voir la correction

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

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 .


c. Pour combien de valeurs de le programme calcule-t-il ?


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 sur un intervalle .

Remarque
Cette méthode qui permet de trouver une réponse « au hasard » s’appelle une méthode de Monte-Carlo. En général, ces méthodes sont peu efficaces, mais elles sont à la base d’algorithme puissants tels que les algorithmes génétiques.


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 la correction

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 : .
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 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
Voir la correction

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 de l’exercice précédent.

1. Créer une fonction Python points ayant comme paramètres deux nombres réels et tels et un entier naturel . Cette fonction doit retourner la liste des nombres de la forme , où est un nombre entier variant avec un pas de dans l’intervalle .
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 la correction

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
Voir la correction

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 telle que .
Ici, l’objectif est d’utiliser la méthode d’Euler pour déterminer une approximation de la solution sur par deux listes X et Y, contenant respectivement une liste croissante de nombres compris entre et et leurs images respectives par .
On admet que, lorsque est très proche de , est une bonne approximation de .

1. On souhaite que la liste X soit la liste des termes successifs d’une suite arithmétique de premier terme et de raison et qui sont inférieurs ou égaux à . Ainsi, si , 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 , montrer que .
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 la correction

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 directement à partir de et . On rappelle que l’on considère l’équation telle que .
Une version un peu améliorée, la méthode d’Euler implicite, est proposée ici.
Au lieu d’utiliser l’approximation , on utilise .

1. Déterminer alors une expression de en fonction de .


2. Modifier la fonction euler_explicite de l’exercice précédent, en prenant en compte la nouvelle expression de .


Voir la correction

13
Formule de Stirling
☆☆

Voir fiche n° 3 : Les fonctions

Soient et les suites définies pour tout entier naturel par et .
À l’aide d’une fonction écrite en Python, conjecturer la valeur de .
On pourra créer une fonction factorielle ou bien utiliser celle du module math de Python.

Remarque
Pour une méthode utilisant le tableur, on pourra se référer à l’exercice page 48 du manuel.




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 .

1. Rappeler l’équation réduite de la tangente à la représentation graphique de la fonction exponentielle, au point d’abscisse , 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 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 définie par : 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 .

a. Déterminer l’expression de . Que retrouve-t-on ?


b. Écrire explicitement les quatre termes de .


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

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


Remarque
On pourra créer une fonction factorielle ou bien utiliser celle du module math de Python.


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 la correction

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 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 .
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 définie sur . On la prolonge par continuité en posant . 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 : . En utilisant Python et éventuellement des fonctions déjà construites dans les exercices précédents, retrouver ce résultat.



Utilisation des cookies
Lors de votre navigation sur ce site, des cookies nécessaires au bon fonctionnement et exemptés de consentement sont déposés.