krang84 6:04 am le April 30, 2013

La fonction racine carré : Partie 1/x

Commençons par poser la définition mathématiques d’une fonction racine carré :

$\sqrt{x}=y$ est équivalent à $y \geq 0$ et $y^2=x$

krang84 1:32 pm le April 24, 2013

Soit la suite $u_n$ définie par $u_n= \frac{3*n^2+100}{7*n}$ pour $n \geq 1$

1) Caclulons les valeurs de $u_1 , u_2 , u_3 , ... , u_7$ à $10^{-2}$ près

1 14.7142857143
2 8.0
3 6.04761904762
4 5.28571428571
5 5.0
6 4.95238095238
7 5.04081632653
>>>

2) Voyons une représentation graphique de cette suite et essayons d’en conjecturer la limite .

Bon il semblerait que les termes filent tout droit vers l’infini .

3) Soit A un nombre réel .
A partir de quel rang a-t-on $u_n \in ]A; + \infty [$

On se base sur le code suivant :
>>>n=1
>>> while(u<=100)
n=n+1
u=(3*(n**2)+100)/(7*n)
>>>print(n)

i) A=10
n=1 , on $u_n=14.71 \in ]10; + \infty[$
ii) A=20
n=46 on a $u_n=20.02 \in ]20; + \infty[$
iii) A=100
n=234 on $u_n \in ]100; + \infty[$
iv) A=5489
n=12808 on a $u_n \in ]5489; + \infty [$
v) A= 100 000
n=233334 on a $u_n \in ]100000 ; + \infty [$

4) Soit A un un réel supérieur à 10

krang84 6:13 am le April 23, 2013

Le problème du rang dans la définition d’une limite

Reprenons , que veut-on dire quand la suite $u_n$ tend vers $l$ quand n devient très grand ?

Pour tout intervalle ouvert contenant $l$ , il existe un rang duquel tous les termes de la suite appartiennent à l’intervalle .

Le problème à chaque fois revient à déterminer ce fameux rang que l’on nomme souvent $n_0$ .

Exemple : Soit une suite $u_n$ ayant pour limite $l$

Cela veut dire que pour tout intervalle ouvert il existe un rang à partir duquel tous les termes de la suite sont dans cet intervalle .

Soit un intervalle ouvert centré en $l$ et r son rayon .
L’intervalle peut donc s’écrire $]l-r ; l+r[$ .
A partir de quel $n_i$ i=0,1,2,… a-t-on $u_n \in ]l-r , l+r[$

A chaque fois il faudra résoudre l’inéquation d’inconnue $n_i$ : $u_{n_i} < l-r$
Et la on aura notre rang .
En effet , on aura une inégalité du type $n_i > k$ et le rang sera [k]+1 .

Exemple : La suite de l’article précédent $u_n= \frac{2*n+1}{n}$ .
La question était de montrer qu’à partir d’un certain rang à déterminer tous les termes de la suite appartenaient à l’intervalle $]2-r ; 2+r [$ ( avec $r > 0$ )

Résolvons donc l’inéquation $u_{n} < 2- r$
$\frac{2*n+1}{n} < 2-r$
$2*n+1 < 2*n+r*n_0$
$1<r*n$
$\frac{1}{r}< n$

Donc dès que $n> \frac{1}{r}$ on a $u_{n} \in ]2-r;2+r[$

on tient notre rang . Maintenant tous les rangs n supérieurs à $[ \frac{1}{r} ] + 1$ ont leurs termes dans l’intervalle .

krang84 6:37 am le April 17, 2013
Tags : fibonacci, recurence, recurrence

Suite de Fibonacci

Soit une suite $F_n$ définie par $F_0=F_1=1$ et sa relation de récurrence $F_{n+2}=F_{n+1}+F_n$ .

Comment calculer les premiers termes de cette suite sous Python ?
Nous savons calculer les termes pour une suite explicite , une suite récurrente . Mais la on a une suite récurrente linéaire d’ordre 2 .

Un préliminaire : l’option end

Exemple :

>>>i=0
>>>while(i<5):
print(i)
i=i+1

0
1
2
3
4

On remarque une chose , le print() affiche les valeurs les uns en dessous des autres .
Faisons un petit changement

>>>i=0
>>>while(i<5):
print(i, end= » « )
i=i+1

0 1 2 3 4

Voila , les valeurs sont affichés les uns a côté des autres .

La différence ??

Dans le print du second exemple on a rajouté un argument end= » »
qui signifie que l’on ne veut pas d’un retour à la ligne mais à la place juste un espace .

Comment coder une suite récurrente linéaire d’ordre 2 ?

balançons le code

>>>a,b,c=1,1,1
>>>while(c<11):
print(b,end= » « )
a,b,c=b,a+b,c+1

1 2 3 5 8 13 21 34 55 89

Décryptons ce code :

La première instruction est une affectation parallèle , les trois variables a , b et c prennent tous la valeur 1 .
Remarque : quel est le rôle de ces trois variables ??
a et b seront surement les variables représentant les termes $F_i$ se succédant .
c sera une variable compteur .

La deuxième instruction est une instruction composée : un while . Sa condition est (c<11) qui est vrai car 1<11 . On entre dans la boucle

Son bloc d’instruction comporte deux instructions .
La première instruction print(b,end= » « )
Finalement on n’affichera que la valeur de la variable b , pour le end voir le préliminaire plus haut . pour l’instant b=1 , la première itération imprimera la valeur 1 .

La deuxième instruction est un piège !!
on pourrait penser que a=b et b=a+b et c=c+1
FAUX .
En fait , a,b=b,a+b est un échange de valeurs .
a prend la valeur de b , et b prend la valeur de a+b (mais l’ancienne valeur de a pas la nouvelle valeur de a qui vaut b)

Exemple:
1ière itération : a prend la valeur de b =1 donc a =1
b prend la valeur de a+b = 1+1 =2
2ième itération : a prend la valeur de b=2 donc a+2
b prend la valeur a+b=1+2 ( on utilise l’ancienne valeur de a) = 3
3ième itération : a prend la valeur de b=3 donc a=3
b prend la valeur a+b = 2+3=5 (ancienne valeur de a)
etc …

et c prend la valeur de c+1 (c = c+1=1+1=2) .

C’est cet échange de valeurs qui permet le calcul des termes .

#fibonacci, #recurence, #recurrence

krang84 7:14 pm le April 16, 2013
Tags : convergence

Limite de suite

Soit la suite $u_n= \frac{1}{n}$ définie pour tout entier naturel n différent de 0 .

Le but de la manoeuvre est de monter qu’il existe un entier N tel que pour tout entier n supérieur ou égal à n , on ait $u_n \in ] - 0.1 ; 0.1 [$

On peut remarquer que dès que l’on a trouver cet entier N , on a $u_n= \frac{1}{n} < 0.1$

Calculons quelques valeurs de la suite . Avec pyhton :
1 1.0
2 0.5
3 0.3333333333333333
4 0.25
5 0.2
6 0.16666666666666666
7 0.14285714285714285
8 0.125
9 0.1111111111111111
10 0.1
11 0.09090909090909091
12 0.08333333333333333
13 0.07692307692307693
14 0.07142857142857142

Intéressant on remarque que si n=10 alors $u_n=0.1$ et dès que $n\geq 11$ on a d’après les valeurs numériques $u_n< 0.1$
Il semble que l’on tient notre entier N qui vaut donc 11 et dès que l’on dépasse cet entier N on ait $u_n < 0.1$ .

On peut voir cela aussi par un calcul :
Suppsons $n \geq N$ cela implique donc $\frac{1}{n} \leq \frac{1}{N}$ et donc $u_n= \frac{1}{n} \leq \frac{1}{11}= 0.09090909090909091 < 0.1$
On remarque aussi que pour tout n différent de 0 . $-0.1< 0 < u_n$

Conclusion : Il existe un entier naturel N tel que pour tout $n \geq N$ on ait $u_n \in ] -0.1 ; 0.1 [$

Montrons que la limite de $u_n$ quand n tend vers l’infini est 0 .

Si nous revenons à la définition d’une limite c’est dire que tout intervalle ouvert contenant 0 contient tous les termes de la suite à partir d’un certain rang .

Si ce que l’on doit démontrer pourrait être vrai pour tous les intervalles ouvert contenant 0 , prenons au hasard un intervalle ouvert $] a ; b [$ avec $a < b$

Remarque : Si 0 appartient à l’intervalle $] a ; b [$ cela est équivalent à $a < 0 < b$ donc on en déduit deux choses 1) $a 0$

Maintenant , la partie la plus difficile est de montrer qu’à partir d’un certain rang que nous appellerons $N_0$ on ait $u_n < b$ (c’est la définition de la limite)

A partir de quel rang on peut avoir cette relation ??

Appelons $N_0$ duquel on a $a < u_{N_0} < b$ ??

On a $\frac{1}{N_0} < b$ d'ou $1 < b * N_0$ mais encore $\frac{1}{b} < N_0$
On tient notre rang : $N_0$

Reprenons , soit $N_0$ notre rang , on a $N_0 > \frac{1}{b}$ d’ou $\frac{1}{N_0} < b$ .
D'ou soit $n \geq N_0$ on a , $\frac{1}{n} \leq \frac{1}{N_0} < b$ d'ou $u_n < b$ .

Une autre remarque : pour tout entier naturel non nul on a $u_n > 0$ d’ou $u_n > 0 > a$ .
D’ou pour tout $n \geq N_0$ , on a $u_n \in ] a ; b[$

On a montré que pour tout intervalle ouvert contenant 0 il existait un rang $N_0$ à partir duquel tous les termes de la suite sont dans l’intervalle .

La suite $u_n = \frac{1}{n}$ converge vers 0 .

#convergence

krang84 7:53 am le April 16, 2013

Suite récurrente

Prenons une suite récurrente que l’on a vu en analyse 101 :

$u_{n+1}= \frac{1}{2}*u_n+1$ et $u_0=4$

Nous voulons calculer ses 10 premiers termes :

Une manière de faire -intuitive-

>>> n=4

>>>n= 1/2 * n + 1

>>> print(n)

>>>n=1/2*n+1

>>>print(n)

2.5

>>>n=1/2*n+1

>>>print(n)

2.25

et donc cela devient répétitif , il y aurait un moyen d’introduire un while quelque part et mettre une variable compteur qui servira à reconnaître les indices des termes .

>>>n,i=4,1

>>>while(i<11):
n=1/2*n+1
print(i,n)
i=i+1

1 3.0
2 2.5
3 2.25
4 2.125
5 2.0625
6 2.03125
7 2.015625
8 2.0078125
9 2.00390625
10 2.001953125

la première instruction est une affectation parallèle , n et i prenant les valeurs 4 et 1 respectivement .
Ce n=4 est évidemment $u_0=4$

la deuxième instruction est une instruction composée : un while . Sa condition est i<11 ce qui est vrai , il fera donc 10 itérations .
Examinons le bloc d’instruction :
La première instruction est une affectation de valeur , elle affecte à la variable n la valeur 1/2*n+1=1/2*4+1=2+1=3
à ce stade n est affecté de la valeur 3 .
Remarque : La nouvelle affectation de la valeur de n fait intervenir dans le calcul son ancienne valeur , bienvenue dans la récursion :p

La deuxième instruction appelle la fonction print pour afficher les valeurs de i et de n ( soit à ce moment 1 et 3)
La troisième instruction affecte la valeur de i de la valeur i+1=1+1=2. La boucle est fini , on revient au début et on commence la deuxième itération .

Remarque : Dans une suite définie de façon explicite , on peut utiliser uniquement une variable qui fait office de compteur et de compteur d’indices de termes .
Pour une suite définie de façon récurrente , il faut une variable n qui est à la fois le compteur d’indices et permet le calcul de la formule de récurrence , et une variable i qui fait office de compteur .

krang84 6:35 pm le April 15, 2013

Conjectures : suites

Soit la suite $u_n=2^n$ définie pour tout entier naturel .
1) Voyons ses 10 premiers termes
2) Emettons une conjecture sur une limite éventuel quand n devient très grand .

1) un peu de code sous python 3 et nous obtenons :
0 1
1 2
2 4
3 8
4 16
5 32
6 64
7 128
8 256
9 512
10 1024

2) On va chercher des plus grandes valeurs :
90 1237940039285380274899124224
91 2475880078570760549798248448
92 4951760157141521099596496896
93 9903520314283042199192993792
94 19807040628566084398385987584
95 39614081257132168796771975168
96 79228162514264337593543950336
97 158456325028528675187087900672
98 316912650057057350374175801344
99 633825300114114700748351602688
100 1267650600228229401496703205376

On voit que le terme de cette suite prend des valeurs de plus en plus grande au fur et à mesure que n devient grand .
Sa limite semble être l’infini .

Etudions une dernière suite $u_n=(-1)^n$ définie pour tout entier n

0 1
1 -1
2 1
3 -1
4 1
5 -1
6 1
7 -1
8 1
9 -1
10 1

cette suite a ses termes qui alternent 1 et -1 :

1 -1 1 -1 1 -1 1 -1 1 -1 1 -1 ….

Infiniment cette suite prendra des valeurs alternés .

Elle ne semble ne pas avoir de limite .

krang84 4:06 pm le April 15, 2013
Tags : limite, Suites ; ( 6 )

Conjecture de suite

Soit la suite $u_n= \frac{1}{n}$ définie pour tout $n \geq 1$ .
a)Calculons ses 10 premiers termes
b)Ses 100 premiers termes pour éventuellement émettre une conjecture de la convergente de cette suite

Ce merveilleux langage de programmation qu’est Python 3 va nous aider à calculer les 10 premiers termes .

>>> n=1
>>> while(n<11):
print(n, 1/n)
n=n+1
1 1.0
2 0.5
3 0.3333333333333333
4 0.25
5 0.2
6 0.16666666666666666
7 0.14285714285714285
8 0.125
9 0.1111111111111111
10 0.1
>>>

2) On répète la même opération ce qui donne :

80 0.0125
81 0.012345679012345678
82 0.012195121951219513
83 0.012048192771084338
84 0.011904761904761904
85 0.011764705882352941
86 0.011627906976744186
87 0.011494252873563218
88 0.011363636363636364
89 0.011235955056179775
90 0.011111111111111112
91 0.01098901098901099
92 0.010869565217391304
93 0.010752688172043012
94 0.010638297872340425
95 0.010526315789473684
96 0.010416666666666666
97 0.010309278350515464
98 0.01020408163265306
99 0.010101010101010102
100 0.01
>>>

On constate que $u_{100}=0.01$ ce qui laisse à penser que quand n devient très grand (n> *placer un très grand nombre ici*) son terme $u_n$ a tendance à se rapprocher de 0 .