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:
On obtient par exemple :
Pour télécharger le programme Python, rendez-vous 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.
Je ne sais pas ce qu’il en est pour vous, mais les programmes de sauvegardes qui existent ne me satisfont pas trop car ne répondant pas à mes attentes bien spécifiques.
Aussi ai-je souhaité créer un programme de sauvegarde qui fait exactement ce que je veux.
Voici une vidéo qui vous montre comment faire, en espérant qu’elle vous inspire pour que vous aussi vous puissiez faire le vôtre.
Pour les abonné.e.s de mathweb, le programme se trouve 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:
Voici une astuce qui pourra sans doute servir à plusieurs d’entre vous.
Une fonction peut quelques fois devoir prendre un nombre variable d’arguments. Par exemple, si l’on souhaite calculer le PGCD de plusieurs nombres, on aimerait que la fonction PGCD (par exemple) accepte 2, 3, 4, … arguments.
Voici sur un exemple comment faire:
def pgcd(*n): def _pgcd(a,b): while b!=0: a,b = b,a%b return a p = _pgcd(n[0],n[1]) for x in n[2:]: p = _pgcd(p,x) return p print(pgcd(165,515,225,65))
Alors ? On kiffe ?
L’ensemble de Julia est, pour un nombre complexe c donné, l’ensemble des points d’affixes \(z_0\) tels que la suite définie pour tout entier naturel n par \(z_{n+1}=z_n^2+c\) est bornée.
Selon les valeurs de c, on peut obtenir des ensembles plutôt jolis:
Pour les personnes abonnées à mathweb.fr, vous trouverez un code Python ainsi que les 10 images (sans marquage) sur cette page.