Chargement de l'audio en cours
Plus

Plus

Analyse
Page numérique

Mode édition
Ajouter

Ajouter

Terminer

Terminer




Analyse





1
Calculer les termes d’une suite ★★

Voir fiche n° 3 : Les fonctions

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

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

2. Compléter la fonction u_nrecursif qui calcule unu_n récursivement, en vous aidant de la relation de récurrence qui définit unu_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 les réponses

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 u0=1u_0=1, u1=1u_1 = 1 et, pour tout entier naturel n1n \geqslant 1, un+1=un+un1u_{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 aa, bb, ii et uu.

i\color{white}i a\color{white}a b\color{white}b u\color{white}u
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 les réponses

3
Théorème de Cesaro
☆☆

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


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

1. Dans le programme ci-après, quelle est la suite (un)(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 (Sn)(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 les réponses

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 2\sqrt{2} par balayage.

1. Modifier cette fonction pour qu’elle renvoie 3\sqrt{3} avec une précision de 0,0010,001.
2. Modifier cette fonction pour qu’elle renvoie ln(2)\ln(2) avec une précision de 0,0010,001.
3. Compléter cette fonction pour qu’elle renvoie ln(x)\ln(x), où xx est un nombre réel strictement positif donné en paramètre, avec une précision de 0,010,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
Voir les réponses

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>0x> 0 donné en paramètre à l’aide d'un algorithme de dichotomie.

1. À quel intervalle doit appartenir xx 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=1000a=-1000 et b=1000b=1000 ?


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


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 les réponses

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 (Snα)(S^{\alpha}_n) définies, pour tout α>1\alpha >1, par :
Snα=11α+12α++1nα=k=1n1kαS^{\alpha}_n=\dfrac{1}{1^\alpha}+\dfrac{1}{2^\alpha}+\dots + \dfrac{1}{n^\alpha} = \displaystyle \sum_{k=1}^{n} \dfrac{1}{k^{\alpha}}.

On donne les valeurs suivantes :
  • limn+Sn2=π26\underset{n \rightarrow +\infty}{ \lim}S^{2}_n=\dfrac{\pi^2}{6} ;
  • limn+Sn4=π490\underset{n \rightarrow +\infty}{ \lim}S^{4}_n=\dfrac{\pi^4}{90} ;
  • limn+Sn6=π6945\underset{n \rightarrow +\infty}{ \lim}S^{6}_n=\dfrac{\pi^6}{945} ;
  • limn+Sn8=π89450\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 nn et α\alpha supérieurs ou égaux à 11 et qui renvoie la valeur de SnαS^{\alpha}_n.

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

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



Voir les réponses

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 ff 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][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][0\:;1].


c. Pour combien de valeurs de xx le programme calcule-t-il f(x)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 ff sur un intervalle [c;d][c\:;d].

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 les réponses

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 : 12x(3x)(3+x)  dx\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 nn 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 les réponses

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 xx(3x)(3+x)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 aa et bb tels a<ba<b et un entier naturel nn. Cette fonction doit retourner la liste des n+1n+1 nombres de la forme a+banka+\dfrac{b-a}{n}k , où kk est un nombre entier variant avec un pas de 11 dans l’intervalle [0;n][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 les réponses

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 les réponses

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)(E) y=yy' = y telle que y(0)=1y(0)=1.
Ici, l’objectif est d’utiliser la méthode d’Euler pour déterminer une approximation de la solution yy sur [0;1][0\,;\,1] par deux listes X et Y, contenant respectivement une liste croissante de nombres compris entre 00 et 11 et leurs images respectives par yy.
On admet que, lorsque hh est très proche de 00, f(x0+h)f(x0)h\dfrac{f(x_0+h)-f(x_0)}{h} est une bonne approximation de f(x0)f'(x_0).

1. On souhaite que la liste X soit la liste des termes successifs d’une suite arithmétique de premier terme 00 et de raison hh et qui sont inférieurs ou égaux à 11. Ainsi, si h=0,4h=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)(E), montrer que y(x+h)(1+h)y(x)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 les réponses

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)f(x+h) directement à partir de f(x)f(x) et hh. On rappelle que l’on considère l’équation (E)(E) y=yy' = y telle que y(0)=1y(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)f(x+h)f(x)hf'(x)\approx \dfrac{f(x+h)-f(x)}{h}, on utilise f(x+h)f(x+h)f(x)hf'(x+h)\approx \dfrac{f(x+h)-f(x)}{h}.

1. Déterminer alors une expression de y(x+h)y(x+h) en fonction de y(x)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)y(x+h).


Voir les réponses

13
Formule de Stirling
☆☆

Voir fiche n° 3 : Les fonctions

Soient (un)(u_n) et (vn)(v_n) les suites définies pour tout entier naturel nn par un=n!u_n=n! et vn=2πn(ne)nv_n = \sqrt{2\pi n} \left(\dfrac{n}{\mathrm{e}}\right)^n.
À l’aide d’une fonction écrite en Python, conjecturer la valeur de limn+vnun\displaystyle\lim_{n \to +\infty} \dfrac{v_n}{u_n}.
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.



Voir les réponses

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

1. Rappeler l’équation réduite de la tangente à la représentation graphique de la fonction exponentielle, au point d’abscisse 00, 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 00 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 fnf_n définie par : fn(x)=k=0nxkk!,f_n(x)= \displaystyle \sum_{k=0}^{n}\dfrac{x^k}{k!},nn 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 00.

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


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


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

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


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 les réponses

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 ff 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 ff.
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 ⁣:xsin(x)xf \colon x \mapsto \dfrac{\sin(x)}{\sqrt{x}} définie sur R\mathbb{R}^*. On la prolonge par continuité en posant f(0)=0f(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 les réponses

16
Intégrale de Gauss
★★

Voir fiche n° 3 : Les fonctions

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



Voir les réponses
Utilisation des cookies
En poursuivant votre navigation sans modifier vos paramètres, vous acceptez l'utilisation des cookies permettant le bon fonctionnement du service.
Pour plus d’informations, cliquez ici.