Category ArchiveInformatique

Etude d’une suite définie par \(u_{n+1} = f(u_n)\)

C’est un classique dans l’étude des suites : on considère une fonction f et on définit une suite par son premier terme \(u_0\) et par la relation \(u_{n+1}=f(u_n)\) pour tout entier naturel n.

Voyons cela avec l’exemple où \(f(x)=\frac{ax+b}{x^2-3x+2}\)…

Installer un serveur SQL sous Windows 10

Avec le programme 2020 de NSI, les enseignant.e.s et élèves trouveront plutôt appréciable le fait d’avoir un serveur SQL sur son ordinateur personnel afin de tester différentes actions.

Introduction aux matrices de rotation

Considérons la configuration suivante :

Dans le repère orthonormé d’origine O, A(x;y) est un point quelconque et A'(x’;y’) est son image par la rotation de centre O et d’angle \(\theta\). On cherche à exprimer x’ et y’ en fonction de x, y et \(\theta\)…

Reconnaître une chaîne de caractères palindrome avec Python

Dans cet article, nous allons manipuler les chaînes de caractères ainsi que les dictionnaires en Python.

Décomposition en produit de facteurs premiers sous \(\LaTeX\) avec Python

Cette tâche semble simple, mais pas tant que ça en définitive… Je voulais en effet créer une commande \(\LaTeX\) acceptant un paramètre (un nombre entier) qui décompose ce dernier en produit de facteurs premiers, et ce à l’aide de Python.

Il est donc naturel de penser à Pythontex. ça, c’est bon… Le problème est que quand on utilise Pythontex, on ne peut pas facilement passer un argument. Je m’explique… avec un code FAUX :

\documentclass[12pt,a4paper]{article}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{pas-math}
\usepackage{pythontex}

\newcommand{\decomp}[1]{
\py{decompose(#1)}
}
\begin{document}
\decomp{120}
\end{document}

Ce script suppose connue la fonction Python decompose (préalablement définie). Le problème ici est que l’argument #1 ne passe pas… Ce code ne donne donc rien d’autre qu’une erreur.

Il faut donc utiliser une astuce… que voici:

\newcommand{\ifactors}[1]{
\begingroup\edef\x{\endgroup
    \noexpand\py{decompose(#1)}}\x}

Ensuite, j’ai voulu enrichir la macro \ifactors de sorte à ce qu’elle puisse afficher en ligne ou en colonne la décomposition comme ceci :

Cette idée m’est venue suite à un échange avec un abonné qui avait des difficultés à faire appel à Xcas pour cette même décomposition (outil inclus dans mon package pas-cours.sty). Il est vrai que faire tourner Xcas dans un document\(\LaTeX\) n’est pas chose simple et mon package pas-cours fait appel à Xcas pour ce genre de calculs. Il fallait donc que je trouve un moyen de contourner ceci.

Pour les abonné.e.s de mathweb.fr, vous trouverez le script \(\LaTeX\) qui inclus bien sûr le script Python de la décomposition. Il y a aussi en en-tête la chaîne de compilation à respecter pour faire tourner Pythontex. Ça se passe sur cette page.

Les k plus proches voisins

Dans le programme de NSI, on abord l’algorithme des k plus proches voisins. Je vais tenter de vous expliquer avec un schéma ce que cela signifie que de trouver de tels voisins.

Prenons l’exemple de points dans un repère orthonormé dans le carré [0;10]x[0;10] : ils sont soit bleus, soit rouges. On dit que “bleu” et “rouge” sont les classes des points.

Si on met au hasard un point dans ce même carré, on peur se demander de quels points est-il le plus proche, ce qui donnera sa classe éventuelle.

J’ai fait un programme en Python qui:

  • choisit au hasard 10 points rouges et 10 points bleus et qui les affichent;
  • choisit un point vert au hasard;
  • qui détermine la distance entre le point vert et chacun des autres points;
  • qui détermine enfin la classe éventuelle du point vert et qui affiche les distances prises en compte.

On obtient par exemple :

Pour télécharger le programme Python, rendez-vous sur cette page.

Lemniscate et parabole

Le but est de créer le GIF suivant:

Code Python

tikz = open("tikz.tex", "w")
text = ''
      
x = -5
while x < 5:
    y = 1/x
    r = (x**2+y**2)**0.5
    if r<10 and abs(y)<10:
        text = text + '\\begin{tikzpicture}[>=latex]\\labase'
        k = -5
        while k <= x:
            p = 1/k
            rr = (k**2+p**2)**0.5
            if rr<10 and abs(p)<10:
                text = text+'\\draw[red] ('+str(k)+','+str(p)+') circle ('+str(rr)+' cm);\n'
            k += 0.1
        text = text + '\\end{tikzpicture}\n'
    x += 0.1

tikz.write(text)
tikz.close()

Ce script génère un fichier tikz.tex dans lequel les dessins sont faits.

Le fichier \(LaTeX\)

\documentclass{article}
\usepackage{tikz}
\usepackage[paperwidth=10cm,paperheight=10cm,margin=0cm]{geometry}
\setlength{\parindent}{0pt}
\newcommand{\labase}{%
\clip (-5,-5) rectangle (5,5);
\draw[->] (-5,0) -- (5,0);
\draw[->] (0,-5) -- (0,5);
\draw plot[domain=-5:-0.1,samples=100] (\x,{1/\x});
\draw plot[domain=0.1:5,samples=100] (\x,{1/\x});
\node[below left] at (0,0) {$O$};
}
\begin{document}
\include{tikz}
\end{document}

En compilant via PdfLaTeX (par exemple), on génère un PDF de 49 pages.

Construction du GIF

J’ai pour habitude d’utiliser GIMP en ouvrant le PDF, puis en inversant l’ordre des calques, puis en sauvegardant en tant qu’animation dans un fichier .gif. Et voilà !

Avec Pythontex

On peut bien entendu créer un tel GIF directement avec pythontex:

% en utilisant Pythontex
\documentclass{article}
\usepackage{tikz}
\usepackage{pythontex}
\usepackage[paperwidth=10cm,paperheight=10cm,margin=0cm]{geometry}
\setlength{\parindent}{0pt}
\newcommand{\labase}{%
\clip (-5,-5) rectangle (5,5);
\draw[->] (-5,0) -- (5,0);
\draw[->] (0,-5) -- (0,5);
\draw plot[domain=-5:-0.1,samples=100] (\x,{1/\x});
\draw plot[domain=0.1:5,samples=100] (\x,{1/\x});
\node[below left] at (0,0) {$O$};
}
\begin{document}
\begin{pycode}
x = -5
while x < 5:
    y = 1/x
    r = (x**2+y**2)**0.5
    if r<10 and abs(y)<10:
        print('\\begin{tikzpicture}[>=latex]\\labase')
        k = -5
        while k <= x:
            p = 1/k
            rr = (k**2+p**2)**0.5
            if rr<10 and abs(p)<10:
                print('\\draw[red] ('+str(k)+','+str(p)+') circle ('+str(rr)+' cm);')
            k += 0.1
        print('\\end{tikzpicture}')
    x += 0.1
\end{pycode}
\end{document}

Les tableaux en \(\LaTeX\)

Je ne sais pas vous, mais perso, je trouve un peu chiant de créer un tableau en \(\LaTeX\), surtout s’il est complexe… Je suis toujours obligé de rechercher à droite et à gauche, et même au milieu, où trouver telle ou telle commande.

C’est la raison pour laquelle j’ai envie de réunir dans cet article tout ce qu’il faut savoir sur les tableaux. Projet ambitieux qui, je présume, s’enrichira au fil du temps…

Les bases

Je ne vais pas tout reprendre, car il existe une page assez complète ici :

https://fr.wikibooks.org/wiki/LaTeX/Tableaux

Les dimensions

Marges des cellules

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}
Sans redéfinir les marges :
\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d\\
\hline
\end{tabular}

\bigskip

En redéfinissant les marges: 
\setlength{\tabcolsep}{1cm}
\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d\\
\hline
\end{tabular}

\end{document}
Redéfinition de la dimension \tabcolsep

Le package cellspace

Il permet de définir des marges verticales par défaut pour éviter que du texte colle aux traits horizontaux.

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{amsmath}
\usepackage{cellspace}
\setlength{\cellspacebottomlimit}{5pt}
\setlength{\cellspacetoplimit}{5pt}
\setlength{\parindent}{0pt}

\begin{document}

Sans utiliser \textit{cellspace} :
\begin{tabular}{|*4{c|}}
\hline
$\dfrac{p}{q}$ & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}

\bigskip

En utilisant \textit{cellspace}:
\begin{tabular}{|*4{Sc|}}
\hline
$\dfrac{p}{q}$ & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}
\end{document}
Utilisation de cellspace dans un tableau LaTeX

Hauteur des cellules : \morestretch

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}

\renewcommand{\arraystretch}{2}
\begin{tabular}{|*4{c|}}
\hline
a & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}

\end{document}
Agrandir la hauteur des cellules d’un tableau LaTeX avec \morestretch

Hauteur personnalisée pour une ligne

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|*4{c|}}
\hline
a & b & c & d\\[1cm]
\hline
e & f & g & h \\
\hline
\end{tabular}


\end{document}
Hauteur personnalisée d’une ligne dans un tableau LaTeX

Ici, nous utilisons l’alias “\\” suivi de la dimensions (avec unité) que nous souhaitons en dessous du texte et avant le trait horizontal suivant (donc la marge basse de la ligne)

Les filets (les traits du tableau)

Épaisseur des filets

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}
Sans redéfinir les marges :
\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d\\
\hline
\end{tabular}

\bigskip

En redéfinissant les marges: \setlength{\arrayrulewidth}{3pt}
\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d\\
\hline
\end{tabular}

\end{document}
Redéfinition de l’épaisseur des traits d’un tableau avec \arrayrulewidth

Un trait vertical dans une cellule : \vline

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d \vline~ e\\
\hline
\end{tabular}

\end{document}
Trait vertical dans une cellule : la commande \vline

Traits en pointillés

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{arydshln}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c:c|}
\hline
a & b\\
\hdashline
c & d \\
\hline
\end{tabular}

\end{document}
Traits en pointillés dans un tableau LaTeX

Traits horizontaux sur quelques cellules

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|c|c|c|}
\hline
a & b & c & d\\
\cline{1-1}\cline{4-4}
e & f & g & h \\
\hline
\end{tabular}

\end{document}
Traits horizontaux sur quelques cellules uniquement dans un tableau LaTeX

Déliminateur “@{…}”

On l’utilise quand on souhaite autre chose qu’un trait entre deux cellules.

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{xspace}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c@{\xspace$\to$\xspace}c|}
\hline
a & b\\
\hline
c & d \\
\hline
\end{tabular}

\end{document}
Autre chose qu’un filet entre deux cellules

Les couleurs

Lignes sur fond de couleurs

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|c|}
\rowcolor{orange!50}
\hline
a & b\\
\hline
c & d \\
\hline
\end{tabular}

\end{document}
Ligne sur fond de couleur dans un tableau LaTeX

Colonne sur fond de couleur

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|>{\columncolor{orange!50}}c|c|}
\hline
a & b\\
\hline
c & d \\
\hline
\end{tabular}

\end{document}
Colonne sur fond de couleur dans un tableau LaTeX

Une seule cellule sur fond de couleur

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|c|}
\hline
\cellcolor{orange!50}a & b\\
\hline
c & d \\
\hline
\end{tabular}

\end{document}
Une seule cellule sur fond de couleur dans un tableau LaTeX

La couleur des filets

Couleur de tous les filets

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}
\arrayrulecolor{red}
\begin{tabular}{|c|c|}
\hline
a & b\\
\hline
c & d \\
\hline
\end{tabular}

\end{document}
Tous les traits en couleurs dans un tableau LaTeX

Couleur d’un trait vertical

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|c|}
\hline
a & b\\
\arrayrulecolor{red}\hline\arrayrulecolor{black}
c & d \\
\hline
\end{tabular}

\end{document}
Un trait vertical en couleur dans un tableau LaTeX

Un trait vertical en couleur

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage[table]{xcolor}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|cc!{\color{red}\setlength{\arrayrulewidth}{2pt}\vline}cc|}
\hline
a & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}

\end{document}
Un seul trait vertical en couleur dans un tableau LaTeX

Fusions

Fusionner des colonnes

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|*4{c|}}
\hline
a & \multicolumn{2}{|c|}{b et c} & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}


\end{document}
Fusionner des cellules avec \multicolumn

Fusionner des lignes

Il est ici nécessaire d’utiliser le package multirows.

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{multirow}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|*4{c|}}
\hline
a & \multirow{2}{*}{b et f} & c & d\\
\cline{1-1}\cline{3-4}
e &  & g & h \\
\hline
\end{tabular}

\end{document}
Fusion de lignes dans un tableau LaTeX avec \multirow

Des traits en diagonale dans une cellule : le package diagbox

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{diagbox}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|ccc|}
\hline
\diagbox{$a$}{$b$} & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}


\end{document}
Utilisation de diagbox dans un tableau LaTeX

Une croix dans une cellule

\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}
\usepackage{diagbox}
\setlength{\parindent}{0pt}

\begin{document}

\begin{tabular}{|c|ccc|}
\hline
\diagbox[width=7mm,height=5mm]{\diagbox[width=7mm,height=5mm,dir=SW]{}{}}{} & b & c & d\\
\hline
e & f & g & h \\
\hline
\end{tabular}

\end{document}
Une croix dans une cellule de tableau LaTeX

Il y a toutefois un petit inconvénient à cette méthode : il faut jouer manuellement sur les dimensions de la cellule.

Alors maintenant, bien entendu, si vous constatez qu’il manque quelque chose d’important, n’hésitez pas à intervenir en commentaire !

Triangle de Pascal construit avec Python et \(\LaTeX\)

Le code Python

def trianglePascal(n):
    T = [[0] * (n+1) for p in range(n+1)]
    for n in range(n+1):
        if n == 0:
            T[n][0] = 1
        else:
            for k in range(n+1):
                if k == 0:
                    T[n][0] = 1
                else:
                    T[n][k] = T[n-1][k-1] + T[n-1][k]
    return T

T = trianglePascal(9)

Ce premier code est intéressant pour voir comment construire une matrice (dont les coefficients sont ceux du triangle de Pascal).

On commence par initialiser notre matrice T en la remplissant de “0”. Puis on la remplit selon la propriété bien connue : \(\binom{n}{k}=\binom{n-1}{k-1}+\binom{n-1}{k}\).

Le code \(\LaTeX\)

On va utiliser PythonTeX :

% sous windows 
% pdflatex --shell-escape -synctex=1 -interaction=nonstopmode %.tex|python C:\Users\trash\AppData\Local\Programs\MiKTeX\scripts\pythontex\pythontex.py %.tex|pdflatex --shell-escape -synctex=1 -interaction=nonstopmode %.tex
% Sous Linux, remplacer "--shell-espace" par "-write18"

\documentclass[10pt,a0paper,landscape]{article}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{diagbox}
\usepackage{pythontex}
\usepackage{nopageno}
\usepackage{colortbl}
\usepackage{tikz}
\usepackage[margin=5mm]{geometry}
\setlength{\parindent}{0pt}
\newcommand{\dashed}{\tikz[baseline=1mm]\draw[gray!50,dashed](0,0)--(0,0.5);}
\begin{document}

\begin{pycode}
n = 50

def trianglePascal(n):
    T = [[0] * (n+1) for p in range(n+1)]
    for n in range(n+1):
        if n == 0:
            T[n][0] = 1
        else:
            for k in range(n+1):
                if k == 0:
                    T[n][0] = 1
                else:
                    T[n][k] = T[n-1][k-1] + T[n-1][k]
    return T


T = trianglePascal(n)

print('\\begin{tabular}{|>{\\columncolor{orange!10}}c|*{',n,'}{c!{\\dashed}}c|}\\rowcolor{orange!10}\\hline\\diagbox[height=8mm]{$n$}{$k$}')
for k in range(n+1):
    print('&',k)
    
for j in range(n+1):
	print('\\\\\\hline ',j)
	for k in range(n+1):
		if k == 0:
			print('&1')
		else:
			if T[j][k] != 0:
				print('&',T[j][k])
			else:
				print('&')

print('\\\\\\hline\\end{tabular}')
\end{pycode} 

\end{document}

Une précision ici : j’ai souhaité séparer chaque colonne par des pointillés. Pour cela, j’ai utilisé une macro TiKZ (pour si peu, ça fait un peu mal quand-même…) car le package arydshln (qui permet de le faire simplement) rentre en conflit avec diagbox… Il fallait donc en sacrifier un! (en fait, ils ne rentrent pas vraiment en conflit mais si on utilise des pointillés dans le tableau, une boîte noire apparaît à la place de l’étiquette “n”). On obtient le document suivant :

Pour les curieux, voici un aperçu des premières lignes et colonnes:

Aperçu du document affichant le triangle de Pascal pour n = 50

Construire le graphe d’une suite avec Python

Dans cet article, nous allons nous intéresser à la construction du graphe d’une suite définie par \(u_{n+1}=f(u_n)\).

Mon objectif est de créer un programme Python qui demande à la personne utilisatrice :

  • la fonction;
  • le premier terme de la suite;
  • le nombre de termes à construire;
  • la fenêtre \( (x_{\min}) \), \( (x_{\max}) \), \( (y_{\min}) \) et \( (y_{\max}) \);
  • le nom sous lequel la figure sera sauvegardée (vide si on ne souhaite pas la sauvegarder).

Les modules

import numpy as np
import matplotlib.pyplot as plt
from sympy import *
x=Symbol('x')
  • Nous aurons besoin du module numpy pour effectuer quelques calculs;
  • ensuite, matplotlib nous servira à effectuer les tracés;
  • le module sympy nous servira à interpréter la saisie de la fonction comme une fonction. À ce titre, on indique que le symbole de la variable est ‘x’.

Saisie de la fonction

def definite_function():
    fonction = input("Entrez l'expression de la fonction : ")
    # convertit la chaîne de caractères en 'fonction'
    f = lambdify(x,fonction,'math') # on utilise le module 'math' ici plutôt que 'numpy' car plus pratique
    fonction_latex = input('Syntaxe LaTeX : ')
    return f,fonction_latex

Ici, on demande de saisir d’une part la fonction (avec une syntaxe “classique”), chaîne de caractères que l’on s’empresse tout de suite de transformer en fonction avec la fonction lambdify du module simpy. Puis, on demande la syntaxe \(\LaTeX\) pour que l’affichage du titre soit plus joli. La fonction retourne un couple constitué de la fonction et de la syntaxe “latexienne” de la fonction.

Les autres saisies

def window():
    xmin = float(input('xmin = '))
    xmax = float(input('xmax = '))
    ymin = float(input('ymin = '))
    ymax = float(input('ymax = '))
    return xmin,xmax,ymin,ymax
    
def definite_first_term():
    u = float(input("Entrez le premier terme : "))
    return u

def definite_nb_terms():
    n = int(input('Nombre de termes à construire : '))
    return n

def definite_name():
    name = input("Entrez le nom de l'image à sauvegarder (appuyez sur [Entrée] si vous ne voulez pas sauvegarder l'image) : ")
    return name

Rien de bien compliqué pour ces quelques fonctions qui permettent de saisir le reste des paramètres.

La fonction de construction du graphe

Nous allons la nommer :

def construct_graph(xmin,xmax,ymin,ymax,f,fonction,u,n,name):

et pour commencer, nous allons nommer la figure:

fig = plt.gcf()

dans l’objectif de la sauvegarder (éventuellement) plus tard.

Tracé de la grille

# tracé du repère et de la grille
    ax = axes([xmin,ymin,xmax,ymax])
    ax.set_xlim(xmin,xmax)
    ax.set_ylim(ymin,ymax)
    ax.xaxis.set_major_locator(MultipleLocator(1.0))
    ax.xaxis.set_minor_locator(MultipleLocator(0.1))
    ax.yaxis.set_major_locator(MultipleLocator(1.0))
    ax.yaxis.set_minor_locator(MultipleLocator(0.1))
    ax.grid(which='minor', axis='x', linewidth=0.25, linestyle='--', color='0.75')
    ax.grid(which='minor', axis='y', linewidth=0.25, linestyle='--', color='0.75')

Tracé de la courbe

# tracé des courbes
    x = np.linspace(xmin, xmax, 201)
    y = [f(x) for x in [xmin+i*(xmax-xmin)/200 for i in range(201)]]
    plt.plot(x,y,color='green')
    plt.plot(x,x,color='red')

On trace ici la courbe représentative de la fonction f ainsi que la droite d’équation \(y=x\).

Construction des termes

for i in range(0,n):
        x = [u,u]
        y = [u,f(u)]
        plt.plot(x,y,linestyle='--',color='blue',linewidth=0.5)
        x = [u,f(u)]
        y = [f(u),f(u)]
        plt.plot(x,y,linestyle='--',color='blue',linewidth=0.5)
        if i != n-1:
            x = [f(u),f(u)]
            y = [f(u),0]
            plt.plot(x,y,linestyle='--',color='orange',linewidth=0.5)
        if i%2 == 0:
            yunder=-0.05
        else:
            yunder = -0.1
        plt.text(u-0.02,yunder,np.around(u,2))
        u = f(u)

On fait une boucle dont le nombre d’itérations est égal au nombre de points que l’on veut. Dans un premier temps, on trace en pointillés la ligne verticale qui va de (u,0) à (u,f(u)), dans un deuxième temps, la ligne horizontale qui va de (u,f(u)) à (f(u),f(u)) puis la ligne verticale qui va de (f(u),f(u)) à (f(u),0) pour avoir le terme suivant sur l’axe des abscisses.

Le titre

#params = {'mathtext.default': 'regular' }
#plt.rcParams.update(params) 
    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')
    title = "Construction des "+str(n)+" premiers termes de la suite définie par\n$u_{n+1}=f(u_n)$ avec $f(x)="+fonction+"$"
    plt.title(title)
    if name != '':
        fig.savefig(name+'.png',dpi=100,bbox_inches='tight')
    plt.show()

On insère maintenant le titre; les deux premières lignes commentées affichent un titre avec une police de caractères par défaut sous Python (ce qui ne me convient pas, mais qui peut plaire à certaines personnes). Les deux lignes suivantes spécifient que l’on souhaite un affichage \(\LaTeX\).

Fonction principale

if __name__ == '__main__':
    f,fonction = definite_function()
    u = definite_first_term()
    xmin,xmax,ymin,ymax = window()
    n = definite_nb_terms()
    name = definite_name()
    construct_graph(xmin,xmax,ymin,ymax,f,fonction,u,n,name)

En exécutant ce programme avec les paramètres suivants:

Saisie

on obtient l’image suivante:

Résultat

Retrouvez le programme complet sur cette page.