Dans un article précédent, je vous expliquais comment créer un GIF avec \(\LaTeX\), et avec une manipulation Gimp. Trouvant la dernière étape un peu… (comment dire pour rester poli ?) … pénible, je vous propose un combi \(\LaTeX\) + Python + ImageMagick.
Un des abonné m’a demandé aujourd’hui s’il était possible de faire du \(\LaTeX\) sous Android. Faisant du \(\LaTeX\) uniquement sur mon PC Windows, je ne m’était jamais posé la question… Mais il y a une solution, et elle est pas dégueu du tout ! Elle s’appelle VerbTeX…
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.
Le but est de créer le GIF suivant:
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.
\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.
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à !
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}
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…
Je ne vais pas tout reprendre, car il existe une page assez complète ici :
https://fr.wikibooks.org/wiki/LaTeX/Tableaux
\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}
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}
\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}
\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}
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)
\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}
\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}
\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}
\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}
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}
\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}
\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}
\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}
\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}
\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}
\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}
\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}
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}
\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}
\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}
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 !
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}\).
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:
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 :
import numpy as np
import matplotlib.pyplot as plt
from sympy import *
x=Symbol('x')
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.
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.
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é 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é 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\).
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.
#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\).
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:
on obtient l’image suivante:
Retrouvez le programme complet sur cette page.
Dans un article précédent, je vous expliquais comment, dans un fichier \(\LaTeX\), on pouvait se servir de Python grâce à l’extension Pythontex.
Maintenant, je vais vous expliquer comment faire l’inverse, à savoir comment créer et compiler un fichier \(\LaTeX\) avec un programme Python.
L’objectif va être le même que dans l’article précédent (cas d’école) : créer 20 développements (avec double distributivité) aléatoires.
import os.path
import random
from sympy import Symbol
from sympy import expand
x=Symbol('x')
J’importe le module os car il va me servir à exécuter des commandes en lignes.
Ensuite, j’importe le module random car il est nécessaire dans notre contexte (dès lors qu’il y a choix aléatoire…).
J’utilise ensuite sympy pour les manipulations algébriques (c’est spécifique ici à ce que je souhaite faire). Je définis alors “x” comme le symbole désignant l’inconnue.
Le contenu du fichier va être défini par une succession de texte.
def preambule(*packages):
p = ""
for i in packages:
p = p+"\\usepackage{"+i+"}\n"
return p
Cette fonction a pour but d’appeler tous les packages nécessaires.
start = "\\documentclass[12pt,a4paper,french]{article}\n\\usepackage[utf8]{inputenc}\n"
start = start+preambule('amsmath','lmodern','babel')
start = start+"\\begin{document}\n\\begin{align*}\n"
end = "\\end{align*}\n\\end{document}"
On commence par définir la classe utilisée (avec les options souhaitées) ainsi que l’encodage. Puis, on appelle tous les packages souhaités. Enfin, on commence le document.
body = ""
for n in range(21):
a = random.choice([1, -1]) * random.randint(2, 9)
b = random.choice([1, -1]) * random.randint(2, 9)
c = random.choice([1, -1]) * random.randint(2, 9)
d = random.choice([1, -1]) * random.randint(2, 9)
e = (a*x+b)*(c*x+d)
eresultchain = str(expand(e)) # on convertit le résultat en chaîne de caractères
eresultchain = eresultchain.replace('**','^') # on met au format TeX les exposants
eresultchain = eresultchain.replace('*','') # on élimine les symboles '*'
echain = str(e)
echain = echain.replace('*','')
body = body+echain+" & = "+eresultchain+"\\\\\n"
Il est ici nécessaire d’anticiper sur la syntaxe \(\LaTeX\) pour remplacer certains caractères…
container = start+body+end
file = "monfichier.tex"
if os.path.exists(file):
os.remove(file)
fichier = open("monfichier.tex","x") # "x" pour la création et l'écriture
fichier.write(container)
fichier.close()
Une fois le fichier créé, il est pratique de le compiler directement puis de l’afficher.
instructions = "pdflatex "+file#" os.system(instructions) readpdf = "START "+file[:-4]+".pdf" os.system(readpdf)
Et voilà ! Une feuille d’exercices créée en à peine 2 secondes…
Les abonné.e.s de ce site trouveront le code complet sur cette page.
Allons droit au but : quand on écrit le code suivant en \(\LaTeX\):
^{235}_{92}U
il s’affiche ceci \(^{235}_{92}U\). Les nombres ne sont pas alignés à droite, ce qui peut déranger certains yeux (dont les miens).
Il existe plusieurs façons d’y remédier. Nous allons voir quelques façons de définir une macro \isotope ayant 3 arguments.
C’est la méthode bourrin… mais qui donne un résultat satisfaisant.
\newcommand{\isotope}[3]{\begin{tabular}{@{}r@{}}#1\\#2\end{tabular}#3}
qui donne ceci :
On peut ensuite affiner le résultat en modifiant la taille des nombres ainsi que leur espacement vertical :
\newcommand{\isotope}[3]{\begin{tabular}{@{}r@{}}\small#1\\[-0.5ex]\small#2\end{tabular}#3}
qui donne, en tapant \isotope{235}{92}{U} dans un texte:
\makeatletter
\newcommand{\isotope}[3]{%
\settowidth\@tempdimb{\ensuremath{\scriptstyle#1}}%
\settowidth\@tempdimc{\ensuremath{\scriptstyle#2}}%
\ifnum\@tempdimb>\@tempdimc%
\setlength{\@tempdima}{\@tempdimb}%
\else%
\setlength{\@tempdima}{\@tempdimc}%
\fi%
\begingroup%
\ensuremath{^{\makebox[\@tempdima][r]{\ensuremath{\scriptstyle#1}}}_{\makebox[\@tempdima][r]{\ensuremath{\scriptstyle#2}}}\text{#3}}%
\endgroup%
}%
\makeatother
J’ai trouvé ce bout de code je ne sais où il y a fort longtemps… L’intérêt n’est pas tant dans le résultat que dans les explications car au final, le résultat n’est pas beaucoup mieux que le précédent :
Explications du code :
Bon, cette méthode, autant vous le dire, n’est là que pour le fun car je vous déconseille de faire une macro graphique pour si peut (même si vous faites ce que vous voulez après tout…).
\newcommand{\isotope}[3]{\tikz[baseline=-0.33\baselineskip,outer xsep=0pt,inner xsep=0pt]{\node (elt) {#3};\node[left] at (elt.north west) {\small#1}; \node[left] at (elt.south west) {\small#2};}}
Voici les trois méthodes les unes à la suite des autres, dans l’ordre traité ici:
Si j’étais vous, ce qui n’est pas le cas, fort heureusement pour vous, j’opterais pour la méthode en \(\LaTeX\) pur car lors de changement de taille de caractères, elle reste insensible et se comporte toujours de la même façon. Par exemple, si on fixe la taille des caractères à 30pt, voilà ce que cela donne:
