Le but est de travailler sur la limite d'une suite lorsque $n$ tend vers $+\infty$.

Par exemple, en langage Python :

# Calcul des 1 000 premiers termes d'une suite pourr conjecturer la limite de la suite.

from math import * # importer la bibliothèque math

def u(n):
	return n**2-1/(n+1) # Définition de la suite.

# Pour calculer les 1000 premiers termes.

for i in range(1000):
	print("u(",i,")=",u(i))

Rappels du cours.

. Une suite $(u_n)$ peut être

• convergente : $\lim\limits_{n \rightarrow +\infty} u_n = "un\,nombre "$
• divergente : $\lim\limits_{n \rightarrow +\infty} u_n = +ou - \infty \,ou\,u_n\,n'a\,pas\,de\,limite. $

Une aide sur la fonction range utilisée. range(i,j) permet de créer un compteur de la valeur i à la valeur j-1. Par exemple, range(10,100) permet de créer un compteur de 10 à 99.

Voici une liste de suites définies par leur expression explicite :

• $u_n=n²-4$
• $v_n=\sqrt{n²+1}$
• $w_n=\frac{n+1}{n²+4}$
• $t_n=\frac{n²}{n+2}$
• $l_n=\frac{n+1}{n+4}$
• $z_n= -4^n$
• $a_n= 0,5^n$
• $y_n=5-\frac{1}{n}$
• $c_n=(-1)^n$
• $c_n=cos (n) $

Utiliser le langage Python afin de visualiser un nombre importants de temes afin de conjecturer la limite de la suite proposée.

Penser à alimenter votre fichier "cahier de TP" avec des commentaires et des copier-collers.

On souhaite calculer les termes de la suite $(u_n)$ définie par $\left\{ \begin{array}{ll} u_{n+1} = 3u_n + 1\\ u_0=2 \end{array} \right.$

from math import *

def u(n) :
	u=2
	for i in range(n):
		u=3*u+1
	return u
	
# Afficher 1000 valeurs.

for i in range(1000):
	print("u(",i,")=",u(i))

# Vous pouvez créer une fonction affichage si vous voulez

def affichage(u,n):
	for i in range(n):
		print("u(",i,")=",u(i))
	return None
	
# Il faudra appeler la fonction affichage par affichage(u,100) dans la console, par exemple.

Faire des tests sur les premiers termes de la suite pour vérification.

Que pensez-vous de la limite de la suite $(u_n)$ ?

Transformez votre code pour afficher les 1000 premiers termes de la suite $v_n$ définie par $\left\{ \begin{array}{ll} v_{n+1} = -v_n + 2\\ v_0=-1 \end{array} \right.$

Que pensez-vous de la limite de la suite $(v_n)$ ?

On donne une suite $u_{n}$ définie par sa relation de récurrence :

$\left\{ \begin{array}{ll} u_{n+1} = 3u_n + 1\\ u_0=2 \end{array} \right.$

On cherche l'indice $n$ tel que $u_{n} \ge 300 $

On a l'algorithme en pseudocode suivant :

u ← 0
n ← 0
tant que u < 300 faire
	n ← n+1 
	u ← u+1

Cet algorithme donne le programme suivant :

from math import *
u=0
n=0
while u <300:
	n=n+1
	u=3*u+1

print(n, u)

Exécuter le programme en Python afin de trouver la valeur de $n$ cherchée.

Sur le même modèle, on cherche l'indice $n$ tel que $v_{n}<100 $ pour $v_{n}$ définie par :

$\left\{ \begin{array}{ll} v_{n+1} = 0.95u_n\\ u_0=200 \end{array} \right.$

Ecrire un programme python pour l'algorithme suivant :

u ← 300
n ← 0
tant que 0.9^n > 150 faire
	n ← n+1 
afficher(n)

Que recherche cet algorithme ?

Vous pouvez transsformer votre programme Python en un ensemble de fonctions :

from math import *

def u(n):
	return ......... # A compléter
	
def seuil(u,s) :   # u est une suite et s est une valeur de seuil
	
	# A compléter
	
	return n

def affichage():
	s=float(input("Entrer votre valeur de seuil : "))
	n=seuil(u,s)
	print(n)
	return None

Le but est de calculer la somme des termes d'une suite numérique.

On donne une suite $u_{n}$ définie par sa relation de récurrence :

$\left\{ \begin{array}{ll} u_{n+1} = 3u_n + 1\\ u_0=2 \end{array} \right.$

On considère l'algorithme suivant :

// u est définie à l'aide d'une fonction

s ← 0
pour i ← 0 à n faire 
	s=s+u(i)

afficher(s)

Cela donne le programme suivant en langage Python :

from math import *

def u(n):
	u=2
	for i in range(i):
		u=3*u+1
	return u
	
s=0
n=5
for i in range(n+1): # Penser qu'il écrire n+1 pour aller jusqu'à n
	s=s+u(i)

print(n, s)

Tester ce code.

Transformer ce code pour que la somme devienne une fonction def somme(u,n) .

from math import * # Importation d'une bibliothèque pour faire de maths.


def f(x):
	return x**2+3*x+1
	
print(f(10)) # Une seule valeur.


# Plusieurs valeurs

for x in range(100): # range(100) génère une liste d'entiers de 0 à 99.
	print(f(x))
	

Définir des fonctions en lien avec le cours actuel pour conjecturer des limites.

valeurs_x=[x for x in range(30)] # permet de créer une liste de 30 valeurs.
valeurs_f=[f(x) for x in range(30)] # permet de créer un tableau de valeurs. 
# valeurs_f=[f(x) for x in valeurs_x] donne le même tableau de valeurs, à tester.

Donner la tableau de valeurs de la fonction définie par $f(x)=x²+3x-1$ pour les valeurs de $x$ comprise entre 0 et 50 (avec un pas de 1)

from math import *
import numpy as np
lx=np.linspace(-10,10,100)

Dans la console, éditer les valeurs de lx. Que représente cette liste de valeurs ?

Compléter votre programme pour afficher la table des valeurs pour les valeurs de $x$ contenues dans lx

Tester le code suivant :

a=-30
b=50
n=1000
lx=np.linspace(a,b,n)
# Penser à afficher lx dans la console

Ecrire une fonction tableau_valeurs(f,a,b,n) qui affiche le tableau des $n$ valeurs comprises entre $a$ et $b$.

def tableau_valeurs(f,a,b,n) :
	lx =  # A compléter
	valeurs_f = # A compléter
	return lx,valeurs_f

Affichage des points

On peut facilement tracer les nuages de points correspondants, en utilisant les fonctions du module matplotlib.

On importe le sous-module pyplot de matplotlib qu’on renomme au passage plt

import matplotlib.pyplot as plt
(v_x, v_y) = tableau_valeurs(f ,-10,10,100)
plt.plot(v_x , v_y , ' . ' , color='red')
plt.show()

Faire des tests avec des fonctions utilisées en classe.