\chapter{Dessiner avec PSTricks}

% Date de la dernière MàJ : 26/02/2019

\label{chap-pstricks}\lettrine{I}{l} n'y a rien de pire que d'apprendre une notion, de l'appréhender, d'expérimenter\dots{} pour se rendre compte qu'une autre est meilleure et qu'il faille tout recommencer depuis le début.

C'est ce qui m'est arrivé avec PSTricks. J'ai appris à dessiner avec ce package, qui requiert de compiler avec le moteur \LaTeX{} ou Xe\LaTeX{}. Puis, j'ai découvert \TikZ{}, qui fonctionne avec n'importe quel moteur de compilation. \\

Je ne vais pas supprimer mon travail initial. Tu peux le consulter. La dernière mise à jour de ce chapitre date du 26 février 2019. Dans tous les cas, \textbf{je te recommande de passer directement au chapitre suivant} sur \TikZ{}.

\section{Fonctionnement général}

Selon le dessin à réaliser, il faut charger un ou plusieurs packages :

\begin{itemize}[label = \ding{213}]
\item \verb?pstricks? : la base pour dessiner avec PSTricks ;

\item \verb?pst-circ? : pour dessiner des circuits électriques ;

\item \verb?pst-node? : pour dessiner des diagrammes ;

\item \verb?pst-eucl? : pour dessiner des figures géométriques ;

\item \verb?pstricks-add? : pour ajouter de nouvelles commandes, comme la rotation d'objets par exemple. \\
\end{itemize}

Ensuite, pour indiquer à \LaTeX{} que nous souhaitons dessiner une image avec PSTricks, il faut utiliser l'environnement \verb?pspicture?, suivi de la taille maximale de l'image au format \verb?(x_max,y_max)?.

Une option supplémentaire, \verb?[showgrid = true]?, est très utile pour visualiser le résultat avec un quadrillage en arrière-plan. Ce dernier permet de corriger des points mal placés ou de faciliter les décalages à faire. \\

Bon, allons faire quelques essais pour mieux saisir le principe de fonctionnement.

\section{Dessiner des circuits électriques}

Le principe de fonctionnement est très simple. Imagine que tu dessines ton circuit électrique sur une feuille de papier. Dans le coin inférieur gauche, tu places un repère et son origine puis tu considères qu'un composant, un fil, etc. revient à se déplacer d'une unité.

Honnêtement, si tu es arrivé jusqu'à cette partie du guide, tu devrais pouvoir aller jeter un coup d'\oe{}il à l'aide du package sans problème, surtout pour avoir accès à toutes les options disponibles. Voici deux petits exemples pour te mettre en bouche :

% Impossible de générer le résultat avec codedisplay ==> utiliser coderesult si insertion souhaité d'un visuel...
\begin{code}{Un cas minimaliste}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor} % Pour les couleurs si besoin
\usepackage{pst-circ} % Pour les circuits électriques


\begin{document}

\everymath{\displaystyle}

\begin{pspicture}[showgrid = true](5,2)
% showgrid affiche le quadrillage
% Permet de se repérer au début et en cas d'erreur
% A mettre sur false lors de la génération du résultat final

% Composants
\resistor(1,1)(2,1){$R$}
% Les coordonnées à renseigner sont celles des extrémités du composant
\coil[dipolestyle = curved](3,1)(4,1){$L$}
	
% Fils
\wire[intensitylabel = $I$, intensitycolor = red, intensitylabelcolor = red](0,1)(1,1)
\wire(2,1)(3,1)
\wire(4,1)(5,1)
	
% Annotations
\tension[labeloffset = -0.5](0.5,0.5)(2.5,0.5){$V$}
% Si coordonnées non entières, utiliser un point
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Un cas plus complet}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor} % Pour les couleurs si besoin
\usepackage{pst-circ} % Pour les circuits électriques


\begin{document}

\everymath{\displaystyle}

\begin{pspicture}[showgrid = true](8,3)
% Composants
\resistor(2,1)(2,2){$R$}
\coil[dipolestyle = curved](4,1)(4,2){$L$} % Un affichage possible pour une bobine
\coil[dipolestyle = elektor](6,3)(7,3){$l$} % Un autre format d'affichage
\resistor(8,1)(8,2){$\frac{r}{g}$}
	
% Fils
\wire[intensitylabel = $I$, intensitylabeloffset = 0.5](0,3)(2,3)
\wire(2,3)(4,3)
\wire[intensitylabel = $I'$](4,3)(6,3)
\wire(7,3)(8,3)
\wire(0,0)(8,0)
\wire(2,0)(2,1)
\wire(2,2)(2,3)
\wire(4,0)(4,1)
\wire(4,2)(4,3)
\wire(8,0)(8,1)
\wire(8,2)(8,3)
	
% Annotations
\tension(0,0)(0,3){$V$}
\end{pspicture}

\end{document}
\end{code}

\begin{conseil}{Conseil personnel}
La génération sous Xe\LaTeX{} peut se révéler assez longue, surtout si tu cumules de nombreux circuits.

Après des essais, le temps d'attente est négligeable avec une compilation sous \LaTeX{}, suivie des conversions d'usage \verb?Dvi -> PS? puis \verb?PS -> PDF?. 

Tu peux donc éventuellement rédiger tout ton rapport avec ce dernier moteur de compilation. Pour rappel, ce dernier ne tolère pas les fichiers \verb?.png? ou \verb?.jpg? pour les images. Il faut donc les convertir en fichier \verb?.eps?, grâce au logiciel \GIMP{} par exemple.
\end{conseil}

\begin{attention}{\textit{Nota Bene}}
Tu as peut-être déjà remarqué que le guide de \verb?pst-circ? utilise une commande \verb?\pnode? pour définir les n\oe{}uds et leur donner une lettre. \\

Il ne s'agit en aucun d'une obligation, comme l'attestent mes précédents exemples. Personnellement, pour un petit schéma, je ne recommande pas de le faire. Je trouve que c'est plus beaucoup plus long s'il faut déplacer des points. 

Cette solution se révèle toutefois plus pratique pour de grands schémas, s'il y a beaucoup de changements à réaliser avant d'obtenir le résultat souhaité et si tu as beaucoup de points communs, par exemple.
\end{attention}

Bon, si tu viens de te rendre compte que \LaTeX{} est extrêmement puissant pour dessiner des circuits d'aussi bonne qualité, sache que ce n'est pas fini. Allons dessiner tout court.

\section{Dessiner tout court}

Pour dessiner avec PSTricks, le principe est extrêmement similaire : tu définis des traits ou des formes à partir de coordonnées et \LaTeX{} trace le tout. C'est parti avec un exemple :

\begin{code}{Un premier dessin : transmission de la chaleur}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks}
% Pas besoin du package xcolor ici
% pstricks l'importe automatiquement


\begin{document}

% Coefficient de transmission thermique d'une paroi
\begin{pspicture}(7,4)
\psline[linecolor = Green](1.5,4)(1.5,0) % Pour tracer une ligne
\psline(2.5,4)(2.5,0)
\psline(3.5,4)(3.5,0)
\psline(4.5,4)(4.5,0)
\psline[linecolor = Green](5.5,4)(5.5,0)
\psline[linecolor = red]{->}(0,2)(7,2)
	
\psframe[fillstyle = hlines](1.5,0)(2.5,4) % Pour tracer un rectangle
\psframe[fillstyle = vlines](3.5,0)(4.5,4)
\psframe[fillstyle = crosshatch](4.5,0)(5.5,4)
	
\rput(2,-0.25){1} % Pour placer une information
\rput(3,-0.25){2}
\rput(4,-0.25){3}
\rput(5,-0.25){4}
\rput(1.5,4.25){\textcolor{Green}{$T_{S_a}$}}
\rput(5.5,4.25){\textcolor{Green}{$T_{S_b}$}}
\rput(7,1.75){\textcolor{red}{$\Phi$}}
\rput(0,3){Ambiance a}
\rput(7,3){Ambiance b}
\rput(0,2.5){$T_a$}
\rput(7,2.5){$T_b$}
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Un second dessin : tracé et hachurage}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage{pstricks}
% Pas besoin du package xcolor ici
% pstricks l'importe automatiquement


\begin{document}

% Création d'un domaine hachuré
\begin{pspicture}(7,7)
% Repère
\psline{->}(0,1)(7,1)
\psline{->}(1,0)(1,7)
\uput[d](7,1){$t_A$} % Plus pratique pour placer une indication décalée
% d = down ; u = up ; l = left ; r = right
\uput[ul](1,7){$t_B$} % Combinaison de position possible DANS CET ORDRE (lu ne fonctionne pas)

\pscircle[fillcolor = black, fillstyle = solid](6,1){0.1} % Pour tracer un cercle + le remplir
\uput[d](6,1){30}
	
% Carré et Delta_t (domaine hachuré)
\psline(6,1)(6,6)(1,6)
\pspolygon[linecolor = red, hatchcolor = red, fillstyle = hlines](3,1)(6,4)(6,6)(4,6)(1,3)(1,1)(3,1)
\rput(6.4,6.4){\textcolor{red}{$\Delta_t$}}
	
\pscircle[linecolor = red, fillcolor = red, fillstyle = solid](3,1){0.1}
\rput(3,0.6){\textcolor{red}{$t$}}
\pscircle[linecolor = red, fillcolor = red, fillstyle = solid](1,3){0.1}
\rput(0.6,3){\textcolor{red}{$t$}}	
\end{pspicture}

\end{document}
\end{code}

\begin{conseil}{Pour plus de commandes}
Je ne vois aucun intérêt à faire une liste des commandes et des options possibles. Je t'ai fourni deux exemples pour que tu aies un aperçu du rendu et des possibilités mais à toi d'aller te documenter par la suite. \\

Je te recommande particulièrement d'aller sur : \url{http://fr.wikibooks.org/wiki/LaTeX/Dessiner_avec_LaTeX/Dessiner_avec_PSTricks}. C'est assez complet.
\end{conseil}

\section{Utiliser des coordonnées}

Dans une optique d'automatisation des dessins (un système d'amortisseur en mécanique ou un circuit RLC, utilisés de nombreuses fois, par exemple), il faudrait pouvoir créer une commande.

L'argument principal de cette commande serait alors un point de départ pour le schéma (en bas à gauche, en haut à droite ou ailleurs, au choix). Sous PSTricks, il s'agirait d'un n\oe{}ud (\verb?node?) et tous les autres sont définis à partir de ce n\oe{}ud d'origine (décalage des abscisses et des ordonnées). \\

L'origine sert donc de ``point d'ancrage'' pour positionner le dessin et le reste est construit automatiquement. Pour ce faire, il faut procéder de la manière suivante :

\begin{itemize}[label = \ding{118}]
\item en plus de \verb?pstricks?, charger le package \verb?pst-node? ;

\item définir tous les n\oe{}uds grâce à la commande : \begin{center} \verb?\psnodes(x1,y1){noeud1}..(xN,yN){noeudN}?\end{center}

En l'occurrence, le n{\oe}ud 1 est l'origine ; \verb?(x1,y1)? est donc remplacé par \verb?(#1)? (argument de la commande) ;

\item définir les \verb?(xi,yi)? en commençant par un \verb?!? et selon la méthode NPI (cf. encadré ci-après) ;

\item récupérer les coordonnées selon l'une des deux manières suivantes :

\begin{itemize}[label = \ding{213}]
\item utiliser la commande \verb?\psGetNodeCenter{noeudi} noeudi.Z?, où \verb?Z? correspond à \verb?x? ou \verb?y? (respectivement, récupération de l'abscisse ou de l'ordonnée),

\item \textbf{ou bien,} introduire la commande \verb?saveNodeCoors? dans les options de l'environnement \verb?pspicture? et utiliser ensuite la syntaxe \verb?N-noeudi.Z?. \\
\end{itemize}
\end{itemize}

Il est aussi possible de définir des longueurs pour continuer de généraliser la commande, comme nous le verrons dans l'exemple qui va suivre.

\begin{definition}{La Notation Polonaise Inverse}
{\noindent\huge\bfseries\color{gray!75}\og}

La notation polonaise inverse (NPI) (en anglais RPN pour \textit{Reverse Polish Notation}), également connue sous le nom de notation post-fixée, permet d'écrire de façon non ambiguë les formules arithmétiques sans utiliser de parenthèses.

{\hfill\huge\bfseries\color{gray!75}\fg} \\

\begin{flushright}
Wikipédia -- Disponible sur :

\url{https://fr.wikipedia.org/wiki/Notation_polonaise_inverse}
\end{flushright}

Concrètement, pour utiliser un exemple, l'opération $((1 + 2) \times 4) + 3$ peut être notée en NPI \verb?1 2 + 4 x 3 +?. Il suffit de partir de la gauche, de prendre deux éléments et un opérateur, de faire le calcul et de le remplacer. Pour détailler, nous avons donc ici :

\begin{itemize}[label = \ding{213}]
\item \verb?1 2 + 4 x 3 +? : prendre \verb?1 2 +? qui devient $1 + 2$ soit 3 ;

\item passage à \verb?3 4 x 3 +? : prendre \verb?3 4 x? qui devient $3 \times 4$ soit 12 ;

\item passage à \verb?12 3 +? qui devient $12 + 3$ soit 15. \\
\end{itemize}

Dans le cadre de PSTricks, le fonctionnement est le même sauf que les opérateurs suivants sont utilisés : \verb?add?, \verb?sub?, \verb?mul? et \verb?div?, respectivement pour addition, soustraction, multiplication et division.
\end{definition}

Avec des exemples commentés, nous obtenons des cas d'utilisation possibles :

\begin{code}{Exemple abstrait (boîte)}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks, pst-node, pstricks-add} 
% pst-node pour les noeuds et le calcul de nouvelles coordonnées
% pstricks-add pour la commande \psrotate

\newcommand{\textedbox}[4]{\pnodes(#1){origine}(#2){fin}
\psframe[#3](origine)(fin) 
\rput(!N-fin.x N-origine.x add 2 div N-fin.y N-origine.y add 2 div){\parbox{\linewidth}{\centering{}#4}}}


\begin{document}

\begin{pspicture}[showgrid = true, saveNodeCoors](10,5)
% saveNodeCoors ssi utilisation de N-node_name.x/y
\def\longueur{4 } % Espace OBLIGATOIRE (sinon rien ne s'affiche)
\def\decalage{0.5 }
% Définition de longueurs
% Possibilité de les mettre en argument d'une commande

% Une option brute
\pnodes(1,1){origine}(!\psGetNodeCenter{origine} origine.x 
\longueur add origine.y \longueur add){fin}
\psframe(origine)(fin)
\psline[linecolor = violet]{|<->|}(!N-origine.x N-origine.y 
\decalage sub)(!N-fin.x N-fin.y \longueur \decalage add sub)
% NE PAS écrire \longueur{}...

% Une commande créée avec l'option saveNodeCoors
\rput(4,0){\psrotate(2.5,2.5){90}{\textedbox{0,2}{5,3}{linecolor = red, framearc = 0.5, linestyle = dashed, fillstyle = hlines, hatchcolor = gray}{\textcolor{cyan}{Texte}}}}

% Une autre possibilité	
\rput(9,2.5){\psframebox[linecolor = orange, framesep = 13pt]{\Large{}Test}}
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Exemple concret (amortisseur)}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks, pst-node} 
% pst-node pour les noeuds et le calcul de nouvelles coordonnées

\newcommand{\amortisseur}[3]{\pnodes(#1,#2){A}(!#1 1 sub #2){B}(!#1 1 sub #2 1 add){C}(!#1 #2 1 add){D}(!#1 0.5 sub #2 1 add){F}(!#1 0.5 sub #2){E}(!#1 0.5 sub #2 0.5 add){G}(!#1 0.5 add #2 0.5 add){H}(!#1 1 sub #2 0.5 add){I}(!#1 2 sub #2 0.5 add){J}(!#1 0.5 sub #2){K}\psline(A)(B)(C)(D) \psline(F)(E) \psline(G)(H) \psline(I)(J) \uput[d](K){#3}}


\begin{document}

Un cas plus concret avec un amortisseur (taille fixe), moins élégante mais qui fonctionne :

\begin{pspicture}[showgrid = true](3,2)
\amortisseur{2}{0.5}{$\mu$}
\end{pspicture}

\end{document}
\end{code}

Comme tu peux le constater, la définition des n\oe{}uds avec cette méthode est, certes, laborieuse mais peut se révéler très pratique avec la possibilité de créer des commandes : au lieu d'avoir une entrée pour l'abscisse de l'origine et une autre pour son ordonnée, tout passe avec un argument et PSTricks fait le reste.

Autrement, dans la définition des n\oe{}uds, avec cette notation, il ne faut \textbf{pas oublier} le \verb?!? et il est important de noter que la séparation des abscisses et des ordonnées se fait \textbf{SANS} virgule\footnote{Pourquoi ? Je n'en sais rien, ça marche comme ça et c'est très bien. Mais il doit bien y avoir une raison\dots{}}.

\section{Des boîtes pour le texte}

Peut-être l'as-tu remarqué dans mon précédent exemple abstrait mais il est possible de créer des boîtes avec le texte centré, et plein d'autres options. 

Ma commande, définie dans l'exemple précédent, serait ``parfaite'' (de mon point de vue) s'il était possible d'extraire la longueur de la boîte pour l'intégrer comme argument de la \verb?parbox?. Sans succès pour l'instant. 

Mais il semblerait qu'elle fonctionne grâce à un petit \verb?\linewidth?. Tant mieux. \\

Sinon, il existe d'autres possibilités sous PSTricks comme la commande \verb?\PSTextFrame?. Une piste à explorer !

\section{Réaliser des intersections}

Tu as envie de tracer un contour qui correspond à l'intersection de deux cercles mais tu ne sais pas comment faire\dots{} Pas de panique, il existe une solution. Je vais présenter celle disponible sous PSTricks, même s'il en existe une aussi sous \TikZ{} (comme elles portent le même nom, la documentation est facile à trouver).

Il faut réaliser un \verb?clip?. Le fonctionnement est très simple : tu définis la zone d'intersection puis tu places un objet assez grand (comme un rectangle) et paf ! Tu obtiens des Chocapics\dots{} bon ok, quand même pas mais le résultat escompté est là et c'est le plus important.

\begin{code}{Réaliser des intersections}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks}


\begin{document}

\begin{pspicture}[showgrid = true](5,5)
% Chemin de coupure / clip
\psclip{
	\pscircle[linestyle = none](1,2){2}
	\pscircle[linestyle = none](4,2){2}
}
% linestyle = none pour ne pas le dessiner

% Remplir l'intérieur du chemin
\psframe*[linecolor = Cyan](0,0)(4,4) 
\endpsclip{}

% Affichage du contour du chemin de coupure
\pscircle(1,2){2} 
\pscircle(4,2){2}
\end{pspicture}

\vspace{2\baselineskip}

\begin{pspicture}[showgrid = true](5,5)
% Chemin de coupure / clip
\psclip{
	\rput{-30}(0,2){\psframe[linestyle = none](0,0)(3,2)} 
	% psrotate inopérant --> travailler avec rput (partir de (0,0), rotation puis décalage)
	\pscircle[linestyle = none](4,2){2}
}
% Remplir l'intérieur du chemin
\psframe*[linecolor = Cyan](0,0)(4,4)
\endpsclip{}
\end{pspicture}

\end{document}
\end{code}

\section{Extraction du contour d'une image}

Il existe une image, une icône bien spécifique que tu as envie de réexploiter mais elle est trop petite et les pixels sont apparents au moindre zoom. Ou bien tu tiens à la créer toi-même sous \LaTeX{} pour obtenir une image vectorielle\dots{} mais autant passer par un logiciel spécialisé parfois (Photoshop, InDesign, etc.).

Même si le résultat n'est pas encore parfait, il est possible de vectoriser une image, plus particulièrement sur des images monochromes. Le plus dur et le seul point qui nous importe est l'obtention du contour de l'image. Dès que nous avons les coordonnées des points, \verb?\psline? suffit, quitte à ajouter des options pour le remplissage. \\

Par contre, pour réussir à obtenir les coordonnées du contour en question, il faut bidouiller de la manière suivante :

\begin{itemize}[label = \ding{118}]
\item vectoriser l'image sous \Inkscape{}, la lisser si nécessaire (enlever les bosses superflues\dots{}) ;

\item exporter le résultat au format \verb?.tex? (option \verb?Enregistrer sous?) ;

\item ouvrir le code obtenu, vérifier les dimensions utilisées puis épurer le code, c'est-à-dire ne garder que les coordonnées et enlever les commandes s'il y en a ;

\item simplifier les coordonnées (beaucoup de décimales pas forcément utiles, surtout à la vue des dimensions utilisées). Possibilité de laisser ce traitement à un algorithme (proposition d'un algorithme Python ci-après),

\item insérer les coordonnées obtenues dans le code \LaTeX{} final de ton image ;

\item bien reporter les dimensions ou les ajuster si besoin. Par exemple : \begin{center} \verb?\psset{xunit = 0.5pt, yunit = 0.5pt}? \end{center}
\end{itemize}

Normalement, le résultat n'est pas trop moche. Tu peux le lisser sous PSTricks sans effort en utilisant la commande \verb?\pscurve? au lieu de \verb?\psline?. \`A toi de jouer !\footnote{Yu-Gi-Oh oh oh\dots{}}

\begin{code}[listing options = {style = mainlststyle, language = Python, xleftmargin = 17pt, numbers = left, numbersep = 13pt, numberstyle = \ttfamily\footnotesize\color{orange!50!red}, keywordstyle = \color{blue}, stringstyle = \color{orange}}]{Simplifier les coordonnées : un algorithme Python}
def reduction(chaine, nombre) :
    """Réduire la valeur des décimales à "nombre" d'une liste de coordonnées (x,y) (variable chaine)"""
    resultat = ""
    i = 0
    while i <= len(chaine) - 1 : 
        # Coordonnée x
        while chaine[i] != "." : 
        # On implémente et on cherche le point (séparateur des décimales)
            resultat = resultat + chaine[i]
            i = i + 1
        for j in range(0, nombre + 1) : 
        # On implémente la quantité de décimales voulues (nombre)
            resultat = resultat + chaine[i + j]
        i = i + nombre + 1
        while chaine[i] != "," : 
        # On a implémenté le nombre souhaité de décimales 
        # --> aller à l'autre coordonnées
            i = i + 1
        
        # Coordonnée y
        while chaine[i] != "." : # Idem
            resultat = resultat + chaine[i]
            i = i + 1
        for j in range(0, nombre + 1) : # Idem
            resultat = resultat + chaine[i + j]
        i = i + nombre + 1
        while chaine[i] != ")" : # Idem
            i = i + 1
        resultat = resultat + chaine[i]
        i = i + 1
    print(resultat)

chaine = "(13.10458,13.112)(13.10458,13.112)(13.10458,13.112)"
nombre = 2
reduction(chaine, nombre)
\end{code}