Représentation graphique d’une série mathématique

Nous introduisons la série \(S_n\) définie par:

\[S_n = \frac{3n-5}{2n+2}\]

où \(S_n\) est un nombre réel et \(n\) un entier positif.

Nous pouvons calculer la liste des \(N\) premiers éléments de cette suite avec une fonction une compréhension de liste:

# nombre de termes
N = 25

# definition de la fonction suite
def F(n):
    ''' retourne l'element Sn de la suite '''
    return (3*n - 5) / (2*n + 2)

# liste des elements
liste_elements = [F(k) for k in range(N)]

Dans ce cas, la suite n’est qu’une version discrete de la fonction F. Nous pouvons représenter sur un même graphique les éléments de la suite et la fonction:

# import des modules
import numpy as np
import matplotlib.pyplot as plt

# trace de la fonction
x = np.linspace(0,N)
plt.plot(x, F(x))

# trace des elements de la suite
plt.plot(range(N), liste_elements, 'og')

[<matplotlib.lines.Line2D at 0x7f6ee9a33950>]

Pour illustrer la façon donc chaque élément est calculé, on peut relier l’argument de la fonction et son image par un segment:

# trace de la fonction
x = np.linspace(0,N)
plt.plot(x, F(x))

# trace des elements de la suite
plt.plot(range(N), liste_elements, 'og')

# trace de la ligne y = 0
plt.plot([0, N], [0, 0], 'g')

# trace des segments
for k in range(N):
    plt.plot([k, k], [0, F(k)], 'k')

Un peu plus intéressant, introduisons maintenant la suite \(u_n\) définie par récurrence:

\[u_{n+1} = u_n - \ln{u_n}\]

Une écriture équivalente est:

\[u_{n+1} = G(u_n), \ \text{avec} \ G(x) = x - \ln{x}\]

Ainsi, le terme \(n+1\) est trouvé en prenant l’image par la fonction \(G\) du terme \(n\). Supposons que \(u_0=10\), on peut alors calculer \(u_1\):

# initialisation de la suite
u0 = 10

# definition de la fonction G
def G(x):
    return x - np.log(x)

# calcul des termes suivants
u1 = G(u0)
u2 = G(u1)

# affichage
print(u1)
print(u2)

7.697414907005954
5.656530360877891

On peut illustrer cela sur le graphique suivant. D’abord, on trace la bissectrice \(y=x\) et la fonction \(G\). Ensuite, pour trouver \(u_1\):

1. on place le point \(U_0 \ (x=u_0, y=u_0)\) sur la bissectrice
2. on place le point \(U_{01} \ (x=u_0, y=G(u_0)=u_1)\) sur la fonction \(G\) en traçant une ligne verticale depuis le point \(U_0\)

Pour trouver le point suivant:

3. on place le point \(U_1 \ (x=u_1, y=u_1)\) sur la bissectrice en traçant une ligne horizontale depuis le point \(U_{01}\)
4. on place le point \(U_{12} \ (x=u_1, y=G(u_1)=u_2)\) sur la fonction \(G\) en traçant une ligne verticale depuis le point \(U_1\)

et ainsi de suite …

# limites des abscisses
xb = 1e-3
xe = 12

# trace de la bissectrice et de la fonction G
x = np.linspace(xb,xe)
plt.plot(x, x)
plt.plot(x, G(x))

# etape 1: point U0
plt.plot([u0], [u0], 'og')

# etape 2: image du point U0 avec une ligne
#   verticale -> U_01
u1 = G(u0)
plt.plot([u0, u0], [u0, u1], 'k')
plt.plot([u0], [u1], 'og')

# etape 3: placer le point U1 sur la bissectrice
#   avec une ligne horizontale depuis U_01
plt.plot([u0, u1], [u1, u1], 'k')
plt.plot([u1], [u1], 'og')

# etape 4: image du point U1 avec une ligne
#   verticale -> U_12
u2 = G(u1)
plt.plot([u1, u1], [u1, u2], 'k')
plt.plot([u1], [u2], 'og')

[<matplotlib.lines.Line2D at 0x7f6ee7803d90>]

On voit que cette visualisation peut se généraliser à N points avec une boucle for:

# limites des abscisses et nommbre de recurrence
xb = 1e-3
xe = 12
N = 10

# trace de la bissectrice et de la fonction G
x = np.linspace(xb,xe)
plt.plot(x, x)
plt.plot(x, G(x))

# Initialisation
plt.plot([u0], [u0], 'og')

# recurrence
for k in range(N):
    # etape 2: image du point U0 avec une ligne
    #   verticale -> U_01
    u1 = G(u0)
    plt.plot([u0, u0], [u0, u1], 'k')
    plt.plot([u0], [u1], 'og')
    # etape 3: placer le point U1 sur la bissectrice
    #   avec une ligne horizontale depuis U_01
    plt.plot([u0, u1], [u1, u1], 'k')
    plt.plot([u1], [u1], 'og')
    # recurrence:
    u0 = u1

On voit que la suite tend vers une limite finie.