dimanche 22 octobre 2017

Suite récurrence (convergente et fonction décroissante) + vitesse de convergence




























Publié par à Aucun commentaire:

Minorants / majorants


Quelques références








Publié par à Aucun commentaire:

Suite récurrente linéaire d'ordre 2

Les suite récurrentes linéaires d'ordre 2 sont la généralisation des suites géométrique (ordre 1). Elle permet notamment de donner l'expression de la suite de Fubonacci. 

Quelques références :
Le point le plus délicat est celui où $\Delta<0$ car suivant si on s'intéresse à une expression réelle ou complexe, il y a deux présentations différentes.









Publié par à Aucun commentaire:

mardi 10 octobre 2017

Code en Python - suite récurrente


Ici je donne un code en Python 3 pour tracer le "colimaçon" donné par la suite

\[u_{n+1}= cos (u_n), \quad u_0= 1.4\]




u[ 0 ]= 1.4
u[ 1 ]= 0.1699671429 
u[ 2 ]= 0.985590325219
u[ 3 ]= 0.552371116616
u[ 4 ]= 0.851282774319
u[ 5 ]= 0.659018879935
u[ 6 ]= 0.790593392425
u[ 7 ]= 0.703423673509
u[ 8 ]= 0.762632118004
u[ 9 ]= 0.723020179449



Attention pour copier le code il faut avoir sélectionner l'article du blog et non d'essayer de le copier de la page principale du blog (car sinon il va compiler le latex qui est dans le code...)
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
# on importe tout d'abord la librairie de maths
# le "as np" permet d'appeler une fonction de numpy en écrivant np seulement
# par exemple np.sin est pour le sinus
import numpy as np
# on importe la librairie de dessin
import matplotlib.pyplot as plt
# on définit notre fonction f
def f(x):
    return np.cos(x)
# on définit la suite u, ce sera un "array", u[0]=1.4 pour le moment
u=[1.4]
# on définit le nombre de point de récurrence
n=10
# on calcule maintenant les n itérations de la suite avec une boucle
# attention range(0,n) va de 0 à n-1.
for i in range(0,n):
    # les boucles les if et le reste sont fait avec des retraits (un tab)
    # avec u.append, on ajoute à l'array u un nouvel élément.
    # au premier tour on a u[1] qui est donné par f(u[0])
    # plus généralement, la commande u[i] va bien donner le i-ème terme de la suite
    u.append(f(u[i]))
    # on imprime les termes au fur et à mesure. Le vert est du texte et le noir
    # est de la donnée
    print('u[',i,']=',u[i])
# on définit les points d'abcisses qui vont servir pour tracer les fonctions
# on va de 0 à pi/2 (le np.pi appelle pi qui est dans la librairie numpy)
# et 0.01 est le pas
x=np.arange(0,np.pi/2,0.01)
# on trace x-> f(x) en b pour blue et - pour le choix du trait
# puis on trace x->x en r pour red et - pour le choix du trait
# en changeant le pas on rend le tracer de la fonction plus ou moins linéraire par morceaux
plt.plot(x, f(x), 'b-', x, x, 'r-')
# Ici on fait des axes jolis
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
# on trace maintenant les traits noir k correspond à black
for i in range(0,n-1):
    plt.plot([u[i], u[i+1]], [u[i+1], u[i+1]], 'k-')
    plt.plot([u[i+1], u[i+1]], [u[i+1], u[i+2]], 'k-')
    # dans la ligne suivante, on trace une ligne entre
    # (u[i],0) et u[i, u[i+1]]. Les "x" sont tous dans le premier crochet
    # et les "y" dans le deuxième
    # on met -- pour avoir un trait en pointillé
    plt.plot([u[i], u[i]], [0, u[i+1]], 'k--')
# il manque le dernier trait alors on le rajoute à la main
plt.plot([u[n-1], u[n-1]], [0, u[n]], 'k--')
# on rajoute des commentaires sur le graphe
plt.annotate('$u_0$', xy=(u[0], 0), xytext=(u[0]+.1, .1),
            arrowprops=dict(arrowstyle="->",
                            connectionstyle="arc3")
            )
plt.annotate('$u_1$', xy=(u[1], 0), xytext=(u[1]+.1, .1),
            arrowprops=dict(arrowstyle="->",
                            connectionstyle="arc3")
            )
# on met un titre, on peut taper en tex!
plt.title('Etude de $u_{n+1}=f(u_n)$')
# on affiche le dessin
plt.show()
# on importe tout d'abord la librairie de maths
# le "as np" permet d'appeler une fonction de numpy en écrivant np seulement
# par exemple np.sin est pour le sinus
import numpy as np

# on importe la librairie de dessin
import matplotlib.pyplot as plt

# on définit notre fonction f
def f(x):
    return np.cos(x)
# on définit la suite u, ce sera un "array", u[0]=1.4 pour le moment
u=[1.4]
# on définit le nombre de point de récurrence
n=10
# on calcule maintenant les n itérations de la suite avec une boucle
# attention range(0,n) va de 0 à n-1.

for i in range(0,n):
    # les boucles les if et le reste sont fait avec des retraits (un tab)
    # avec u.append, on ajoute à l'array u un nouvel élément.
    # au premier tour on a u[1] qui est donné par f(u[0])
    # plus généralement, la commande u[i] va bien donner le i-ème terme de la suite
    u.append(f(u[i]))
    # on imprime les termes au fur et à mesure. Le vert est du texte et le noir
    # est de la donnée
    print('u[',i,']=',u[i])

# on définit les points d'abcisses qui vont servir pour tracer les fonctions
# on va de 0 à pi/2 (le np.pi appelle pi qui est dans la librairie numpy)
# et 0.01 est le pas
x=np.arange(0,np.pi/2,0.01)
# on trace x-> f(x) en b pour blue et - pour le choix du trait
# puis on trace x->x en r pour red et - pour le choix du trait
# en changeant le pas on rend le tracer de la fonction plus ou moins linéraire par morceaux
plt.plot(x, f(x), 'b-', x, x, 'r-')

# Ici on fait des axes jolis
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

# on trace maintenant les traits noir k correspond à black
for i in range(0,n-1):
    plt.plot([u[i], u[i+1]], [u[i+1], u[i+1]], 'k-')
    plt.plot([u[i+1], u[i+1]], [u[i+1], u[i+2]], 'k-')
    # dans la ligne suivante, on trace une ligne entre
    # (u[i],0) et u[i, u[i+1]]. Les "x" sont tous dans le premier crochet
    # et les "y" dans le deuxième
    # on met -- pour avoir un trait en pointillé
    plt.plot([u[i], u[i]], [0, u[i+1]], 'k--')
# il manque le dernier trait alors on le rajoute à la main
plt.plot([u[n-1], u[n-1]], [0, u[n]], 'k--')

# on rajoute des commentaires sur le graphe
plt.annotate('$u_0$', xy=(u[0], 0), xytext=(u[0]+.1, .1),
            arrowprops=dict(arrowstyle="->",
                            connectionstyle="arc3")
            )
plt.annotate('$u_1$', xy=(u[1], 0), xytext=(u[1]+.1, .1),
            arrowprops=dict(arrowstyle="->",
                            connectionstyle="arc3")
            )
# on met un titre, on peut taper en tex! 
plt.title('Etude de $u_{n+1}=f(u_n)$')
# on affiche le dessin
plt.show()
Publié par à Aucun commentaire:
Libellés : , , ,

Théorème Rolle et théorème des accroissements finis

Plus tard dans le cours nous traiterons les développements de Taylor et les développements limités. Pour le moment nous avons des théorèmes de base. Le théorème de Rolle et le théorème (et inégalité...) des accroissements finis.

J'attire l'attention qu'on se limitera au cas de la dimension 1.

Un cours complet avec preuve est disponible ici. 
Publié par à Aucun commentaire:

Exercice corrigé, fonction définie par récurrence (croissante + contractante)


Dans cet exercice on étudie la suite donnée par $u_{n+1}= f(u_n)$ avec $f(x):= \sqrt{1+x}$ et $u_0=1$.

Ici l'exercice est en deux parties.
  • La première est la plus classique et est basée sur la continuité et la croissante de $f$ (on avait déjà vu un exercice avec la décroissance de $f$). 
  • La deuxième partie est basée sur le fait que $f$ est "contractante", $f$ est dérivable et sa dérivée est strictement inférieure à $1$ sur un intervalle. Même si cela ressemble beaucoup à tuer une mouche avec un canon ici, cette méthode est très classique et utile pour donner l'approximation de certains nombres (qui sont donnés comme étant une solution de $x=f(x)$ ). Elle utilise de façon crucial le théorème des accroissements finis. 




On commence toujours par l'étude de la fonction.



On intuite ensuite (comme on peut) le résultat avec un dessin de type colimaçon.





Ici en rouge on trouve une version alternative pour montrer que la suite est strictement croissante (qui n'est pas demandé ici).





Ici, la continuité est un élément essentiel. Ne pas le mentionner à ce moment est pour sûr une source de perte de points...

La partie classique de type "fonction croissante" est finie. On passe à la partie contractante.



On explique ici pourquoi on espère le résultat en se basant, sur le théorème des accroissements finis à chaque étape.



On repart sur la correction. D'un point de vue général, le point clé pour cette méthode marche si $|f'(l)|<1$ et si la dérivée est continue.





Ici intervient un suite géométrique. 

On remarque que l'on aurait pu montrer directement que la suite converge grâce à cette méthode en montrant qu'elle est de Cauchy (comme l'espace est complet). 






Publié par à Aucun commentaire:
Libellés : , , , ,

lundi 9 octobre 2017

Quelques méthodes pour montrer qu'une suite converge


Voici une liste (non-exhaustive) de méthodes qui permettent de montrer qu'une suite converge. On rappelle que la plus part du temps on montre en premier la convergence et puis on trouve la valeur de la limite.

Tout d'abord quelques liens :

  • Une manière introductive pour parler de limite est présente ici. 
  • Un cours niveau terminal sur le sujet ici. 
  • Une ancienne leçon de CAPES sur le sujet ici. 
  • Un cours universitaire sur les suites numériques ici.








Publié par à Aucun commentaire:
Libellés : , ,
Inscription à : Articles (Atom)