On souhaite calculer les termes de la suite $(u_n)$ définie par $u_n=4*n²+1$

from math import *

def u(n) :
	
	return 4*n**2+1 # n**2 signifie n²
	
# Afficher 1000 valeurs.

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

Coder les différentes suites proposées ci-dessous :

Vous pouvez définir chaquue suite par une fonction différente dans le même programme python.

• $u_n=n²-4$
• $v_n=\sqrt{n²+1}$
• $l_n=\frac{n+1}{n+4}$
• $z_n= -4^n$
• $a_n= 0,5^n$
• $ b_n = -3n +2 $
• $y_n=5-\frac{1}{n}$ Vous devriez rencontrer un problème. Identifier le problème. Quelle solution envisagée ?
• $c_n=(-1)^n$
• $d_n=cos (n) $

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.

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

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

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.

Calculer le nombre dérivé d'une fonction en utilisant la définition.

Rappel : $f'(a)=\lim \limits_{h \rightarrow 0} \frac{f(a+h)-f(a)}{h}$

Utiliser la fonction définie par $f(x)=2x²+3x-1$