Archive de l’étiquette pythontex

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.

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}

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

Engendrer une feuille d’exercices aléatoires avec Python en \(\LaTeX\)

Combien de fois ai-je voulu générer automatiquement des exercices similaires (par exemple, de développement) ? Vous ne le savez pas, mais moi, je le sais : beaucoup trop !

Encore aujourd’hui, j’ai voulu générer une série de multiplications pour faire réviser ses tables une de mes élèves.

Comme je me suis mis à Python il n’y a pas longtemps, et comme dans la foulée je me suis aussi mis à PythonTeX, j’ai forcément pensé à tout ça pour faire ma feuille d’exercices (plutôt que d’inventer et de taper plus de 90 opérations).

Nous allons voir comment.