Club LinuX Nord-Pas de Calais

Pourquoi les écoles doivent utiliser exclusivement du logiciel libre

tems — 2015-08-29T23:29:34Z

Les activités liées à l'éducation, y compris les écoles depuis le jardin d'enfants jusqu'à l'université, ont pour devoir moral de n'enseigner que le logiciel libre.

Tout utilisateur d'informatique devrait exiger des logiciels libres car ils lui donnent la possibilité de contrôler son propre ordinateur – avec les logiciels privateurs en effet,^a le programme fait ce que son propriétaire ou son développeur veut qu'il fasse, pas ce que l'utilisateur veut qu'il fasse. Le logiciel libre donne également aux utilisateurs la liberté de coopérer, de vivre dans la droiture morale. Ces raisons s'appliquent aux écoles comme à tout le monde. Toutefois, le but de cet article est de présenter les arguments supplémentaires qui s'appliquent spécifiquement à l'éducation.

Le logiciel libre fait économiser de l'argent aux écoles, mais c'est un avantage secondaire. Il permet des économies car il donne aux écoles, comme aux autres utilisateurs, la liberté de copier et redistribuer les logiciels ; l'Éducation nationale (ou tout système éducatif) peut en donner des copies à toutes les écoles, et chacune peut installer les programmes sur tous ses ordinateurs, sans avoir besoin de payer pour le faire.

Cet avantage est utile, mais nos refusons catégoriquement de lui donner la première place, parce qu'il est superficiel comparé aux questions éthiques importantes qui sont en jeu. Faire migrer les écoles vers le logiciel libre représente bien plus qu'un moyen de rendre l'éducation un peu « meilleure » : il s'agit ici de faire de la bonne éducation plutôt que de la mauvaise éducation. Approfondissons donc la question.

L'école a une mission sociale, celle de former les élèves à être citoyens d'une société forte, capable, indépendante, solidaire et libre. Elle doit promouvoir l'utilisation de logiciel libre tout comme elle promeut la conservation des ressources naturelles et le vote. En formant les élèves et étudiants au logiciel libre, elle donnera leur diplôme à des citoyens prêts à évoluer dans une société numérique libre. Cela aidera la société toute entière à échapper à la domination des multinationales.

En revanche, enseigner un programme non libre revient à implanter la dépendance, ce qui va à l'encontre de la mission sociale de l'école. Les écoles ne doivent jamais le faire.

Pourquoi, après tout, certains développeurs de logiciels privateurs offrent-ils des exemplaires gratuits (1) de leurs programmes non libres aux écoles ? Parce qu'ils veulent se servir d'elles pour implanter la dépendance à leurs produits, comme le faisaient les industriels du tabac qui ont distribué des cigarettes gratuites à des enfants d'âge scolaire (2). Ces développeurs ne donneront pas d'exemplaire gratuit à ces élèves et étudiants une fois qu'ils auront leur diplôme, ni aux entreprises pour lesquelles ils travailleront. Une fois dépendant, il vous faut payer.

Le logiciel libre permet aux élèves et étudiants d'apprendre comment les programmes fonctionnent. Certains programmeurs-nés, une fois adolescents, ont soif d'apprendre tout ce qu'il y a à savoir de leur ordinateur et de ses logiciels. Ils sont extrêmement curieux de lire le code source des programmes qu'ils utilisent tous les jours.

Le logiciel privateur rejette cette soif de connaissance ; il dit : « Le savoir que tu recherches est un secret – apprendre est interdit ! » Le logiciel privateur est par essence l'ennemi de l'éducation, aussi ne doit-il pas être toléré à l'école, sauf comme objet de rétroingénierie.

Le logiciel libre encourage tout le monde à apprendre. La communauté du logiciel libre rejette ce « culte de la technologie » qui maintient le grand public dans l'ignorance de son fonctionnement ; nous encourageons les élèves et étudiants de tous âges et toutes origines à lire le code source et à apprendre autant qu'ils veulent savoir.

Les écoles qui utilisent du logiciel libre permettent aux apprentis programmeurs doués de progresser. Comment les programmeurs-nés apprennent-ils à être de bons programmeurs ? Ils ont besoin de lire et de comprendre de vrais programmes que les gens utilisent réellement. On apprend à écrire du code bon et clair en lisant beaucoup de code et en écrivant beaucoup de code. Seul le logiciel libre le permet.

Comment apprend-on à écrire le code des grands programmes ? En apportant beaucoup de modifications à de grands programmes existants. Le logiciel libre permet de le faire ; le logiciel propriétaire l'interdit. Toute école peut donner à ses élèves ou étudiants une chance de maîtriser l'art de la programmation, mais seulement si c'est une école du logiciel libre.

La raison la plus profonde d'utiliser du logiciel libre dans les écoles concerne l'éducation morale. Nous attendons de l'école qu'elle enseigne aux élèves et étudiants des connaissances de base et des compétences utiles, mais c'est seulement une partie de sa mission. Sa mission la plus fondamentale est d'enseigner la bonne citoyenneté, y compris l'habitude d'aider les autres. Dans le domaine de l'informatique, cela signifie apprendre aux élèves à partager les logiciels. Il faut qu'on leur dise dès la maternelle : « Si tu apportes un logiciel à l'école, tu devras le partager avec les autres élèves. Tu dois montrer le code source à la classe, au cas où quelqu'un voudrait s'instruire. Il est donc interdit d'apporter du logiciel privateur en classe, sauf pour les exercices de rétroingénierie. »

Bien entendu, l'école doit pratiquer ce qu'elle prêche : elle doit fournir à la classe uniquement des logiciels libres (sauf pour les soumettre à la rétroingénierie) et en partager des exemplaires avec les élèves (y compris le code source) pour qu'ils les copient, les emportent à la maison et les redistribuent autour d'eux.

Enseigner l'utilisation des logiciels libres aux élèves et étudiants et prendre part à la communauté du logiciel libre est une forme concrète d'éducation à la citoyenneté. De plus, cela propose aux étudiants un modèle basé sur le service public au lieu de celui que prônent les magnats de l'économie. Les écoles de tous niveaux doivent se servir de logiciel libre.

Si vous êtes dans le milieu de l'enseignement – que ce soit comme élève, étudiant, enseignant, employé, administrateur, donateur ou parent – il est de votre responsabilité de faire campagne pour que l'école migre vers le logiciel libre. Si une demande faite en privé ne permet pas d'atteindre ce but, portez la question sur la place publique dans ces communautés ; c'est ainsi que les gens prendront conscience du problème et que vous trouverez des alliés dans votre campagne.

Attention, l'école qui acceptera une telle offre pourrait trouver les mises à jour ultérieures plutôt onéreuses.
L'industriel du tabac RJ Reynolds Tobacco Company fut condamné à 15 millions de dollars d'amende en 2002 pour avoir fourni des échantillons gratuits de cigarettes à l'occasion d'événements auxquels participaient des enfants. Voir http://www.bbc.co.uk/worldservice/sci_tech/features/health/tobaccotrial/usa.htm.

Voir en ligne : http://www.nplug.be/node/141

Imprimer un grand document sur des feuilles A4

David Cobac — 2007-01-30T07:57:18Z

M'intéressant à la généalogie, j'ai conçu un arbre dont la dimension dépasse largement celle d'un A4.
Le driver de mon imprimante ne le faisant pas, j'ai alors cherché sur Internet le moyen de découper mon document et là ... pas beaucoup de solutions, voire pas du tout !

Pas n'importe quel document

Il ne s'agit pas d'un document quelconque : il s'agit d'un fichier de type EPS ; je dis de type EPS car en fait il s'agit d'un fichier créé par metapost.

Quelles différences avec un autre type de document allez-vous me dire ?
Hé bien c'est simple :

c'est « lisible » puisque c'est un fichier de type texte ;
il est parfaitement « encadré » : c'est-à-dire que dans les premières lignes du document (celles décrivant le type de document, les lignes non interprétées) se trouve une ligne très particulière : la « Bounding Box ». C'est cette dernière chose qui est particulièrement intéressante.

La Bounding Box

Voilà ci-dessous par exemple les premières lignes de mon fichier :

%!PS %%BoundingBox: -2700 -36 2749 908 %%Creator: MetaPost %%CreationDate: 2007.01.05:1058 %%Pages: 1 %*Font: futr8r 13.1985 9.96265 28:c600007fedbb607ffffee0000000000000000000400000 01c %*Font: futb8r 13.1985 9.96265 41:f779b6 %*Font: fourier-ms 10.03638 9.96265 b1:800008 %*Font: futr8r 10.03638 9.96265 28:c4ffc17fbfbb007fdfff6000000000000000000040000 020d0001 %*Font: futb8r 10.55885 9.96265 41:f9befbc0000000000000000000000000008 %%EndProlog

La ligne qui m'intéresse est évidemment :
%%BoundingBox: -2700 -36 2749 908

Il s'agit de deux paires de coordonnées :

-2700 -36 est le premier point de coordonnées (-2700,-36) ;
2749 908 est le deuxième point de coordonnées (2749,908).
En clair, le premier point est le point supérieur gauche du document et le deuxième, le point inférieur droit.

Bref, je connais les dimensions de mon document...si je connais l'unité utilisée.
Hé bien l'unité est le « point postscript », si on ne sait pas, un petit tour sur google : 1 point PostScript = 0,352777778 millimètres
Ainsi, une rapide conversion me dit que mon document fait une largeur de 192.23 cm (soit 1m 92 !) et une hauteur de 33.30 cm.

Une réduction et un découpage

Ainsi, ce document fait un peu plus en hauteur qu'une page A4 en orientation portrait (pas de chance). On va donc le réduire un peu, en enlevant de notre page A4 1cm en bas et en haut, il nous reste 27.7 cm, ce qui nous fait une réduction d'environ 17%. Le coefficient multiplicateur à appliquer est donc 0.83
Notre largeur sera alors d'environ 159.9 cm, presque 1m 60.
Là encore, en enlevant 1 cm de chaque côté de notre page A4, il nous faudra 9 pages.

Le principe

Nous allons faire un document LaTeX constitué de 9 pages, chacune d'elles contenant le bon bout de notre fichier EPS. Pour cela nous utiliserons le package graphicx donnant accès à la commande « \includegraphics ». Cette commande peut afficher, grâce à l'option bb, une partie d'une image EPS en indiquant la zone à afficher par le principe de la « Bounding Box ».

Je dois donc former 9 « Bounding Box » consécutives, les voilà :

bb=-2700 -36 -2095 908

bb=-2095 -36 -1490 908

bb=-1490 -36 -885 908

bb=-885 -36 -280 908

bb=-280 -36 325 908

bb=325 -36 930 908

bb=930 -36 1535 908

bb=1535 -36 2140 908

bb=2140 -36 2745 908

On remarque que la division par 9 ne tombe pas juste, il faut donc réajuster de 4 points postscript notre largeur, la dernière sera donc réajustée à :
bb=2140 -36 2749 908

Le fichier LaTeX

Il n'y a donc plus qu'à constituer notre fichier LaTeX :

\documentclass{article} \usepackage[a4paper,text={19cm,27.7cm},dvips]{geometry} \usepackage[dvips]{graphicx} \usepackage{pstricks} \pagestyle{empty} \begin{document} \includegraphics[bb=-2700 -36 -2095 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=-2095 -36 -1490 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=-1490 -36 -885 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=-885 -36 -280 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=-280 -36 325 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=325 -36 930 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=930 -36 1535 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=1535 -36 2140 908,clip,scale=.83]%% {monfichier.eps} \newpage \includegraphics[bb=2140 -36 2749 908,clip,scale=.83]%% {monfichier.eps} \end{document}

Cerise sur le gâteau

C'est bien mais pour découper c'est pas terriblement efficace sans pointillés (ou plutôt traits-tillés (!)), alors on fait une commande de pointillés :

\newcommand{\separation}{%% \begin{pspicture}(0,0)%% \psline[linestyle=dashed,linewidth=.05mm](0pt,-1.5cm)(0pt,28.5cm)%% \end{pspicture}}

Et notre code LaTeX devient :

\documentclass{article} \usepackage[a4paper,text={19cm,27.7cm},dvips]{geometry} \usepackage[dvips]{graphicx} \usepackage{pstricks} \pagestyle{empty} \newcommand{\separation}{%% \begin{pspicture}(0,0)%% \psline[linestyle=dashed,linewidth=.05mm](0pt,-1.5cm)(0pt,28.5cm)%% \end{pspicture}} \begin{document} \includegraphics[bb=-2700 -36 -2095 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=-2095 -36 -1490 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=-1490 -36 -885 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=-885 -36 -280 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=-280 -36 325 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=325 -36 930 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=930 -36 1535 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=1535 -36 2140 908,clip,scale=.83]%% {monfichier.eps}\separation \newpage \separation%% \includegraphics[bb=2140 -36 2749 908,clip,scale=.83]%% {monfichier.eps}\separation \end{document}

Il n'y a plus qu'à compiler notre monfichier.tex :

$ latex monfichier

puis de produire un fichier PostScript :

$ dvips monfichier.dvi -o

Et nous obtenons notre joli monfichier.ps

Le gâteau est un peu pourri

Génial direz-vous...mais non, en fait pas terriblement efficace, en effet le fichier que je viens de produire, ici à la maison :-) , pèse finalement environ 2,4 Mo alors que mon image de départ pèse à peine 251 Ko ! Hé bien oui, c'est bien loin d'être un découpage, l'image est tout simplement copié 9 fois dans le fichier produit finalement.

Automatiser

Lire avec une expression régulière la ligne de la « Bounding Box » est une évidence, faire une petite conversion d'unités et une petite division aussi.
Donc le processus décrit dans cette page peut relativement facilement être scripté ; par contre, son intérêt est limité par la taille des fichiers obtenus : si mon arbre augmente en hauteur, j'aurais au moins 2 pages A4 en hauteur et au total 18 feuilles d'où un fichier d'environ 5 Mo... le jeu n'en vaut assurément pas la chandelle !

Certains parleront de la commande poster. Chez moi, elle n'a tout simplement pas fonctionné malgré des heures d'efforts et des passages par pstops.
C'est bien dommage car dans l'absolu, c'est une commande qui simplifie largement les choses !
Si vous avez une solution qui est plus efficace notamment au niveau de la taille finale, n'hésitez pas à me contacter : elle m'intéresse vivement !

Présentation d'opérations avec la classe Beamer de LaTeX et le package xlop

David Cobac — 2007-01-30T07:54:54Z

Il s'agit de faire une présentation d'une simple addition en faisant apparaître au fur et à mesure le calcul posé.
Pour ce faire, j'utilise la fabuleuse classe Beamer de LaTeX avec le non moins fabuleux package xlop.

Le code basique de mon opération avec xlop

Considérons le package xlop. Il permet d'effectuer des opérations en précision quelconque et de les présenter éventuellement sous forme posée.
Pour une opération basique posée :

\opadd{128.05}{43.1}

voici ce qui est obtenu :

On voit, hélas, tout apparaître. Nous allons décomposer l'opération en différentes étapes (comme à la main) :

Étape 1 : on enlève le résultat et la retenue

On les dessine donc en blanc (couleur de fond de page), la couleur blanche est obtenue avec le package xcolor en rajoutant la commande suivante dans notre entête de fichier LaTeX :
\newcommand{\blanc}{\textcolor{white}}
De plus, je réduis un peu la taille de la retenue.

Notre opération est donc :
\opadd[resultstyle=\blanc,carrystyle=\small\blanc]{128.05}{43.1}

Étape 2 : on ajoute les zéros inutiles

On remplace les « blancs » de l'opération par des zéros :
\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false]{128.05}{43.1}

Étape 3 : on met en évidence en rouge la première opération

La première est l'addition du 5 et du 0, on les colorie en rouge (couleur fabriquée de la même manière que précédemment, voir l'entête finale dans la suite) ; pour cela xlop possède une indexation par ligne et colonne des opérandes, un indice négatif corrspondant à une position derrière la virgule, un traitement identique se fera tout au long des étapes dans lesquelles les opérations effectuées seront mises en évidence alors que celles précédemment faites seront mises en noire.

\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false,%% operandstyle.1.-2=\rouge,operandstyle.2.-2=\rouge,resultstyle.-2=\rouge]{128.05}{43.1}

Étape 4 : on efface l'opération précédente et on dessine en rouge la suivante

\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false,%% operandstyle.1.-1=\rouge,operandstyle.2.-1=\rouge,resultstyle.-1=\rouge]{128.05}{43.1}

Étape 5 : traitement de la retenue

La retenue apparaît, on la met en plus petit et en rouge :

\opadd[resultstyle=\blanc,carrystyle=\small\rouge,deletezero=false,%% operandstyle.1.1=\rouge,operandstyle.2.1=\rouge,resultstyle.1=\rouge]{128.05}{43.1}

Dernières étapes

Je vous laisse deviner la suite des événements c'est pas bien compliqué. Une fois, toutes les opérations intermédiares effectuées, il n'y plus qu'à réafficher l'ensemble, c'est-à-dire avec le résultat final.

Une présentation « à la Beamer »

Le squelette type d'un document beamer simple pour notre usage est le suivant :

\documentclass{beamer} %% pour le français \usepackage[frenchb]{babel} %% pour des polices compatibles pdf \usepackage{aeguill} %% pour xlop et les couleurs \usepackage{xlop} \usepackage{xcolor} %% définition de mes couleurs \newcommand{\blanc}{\textcolor{white}} \newcommand{\noir}{\textcolor{black}} \newcommand{\rouge}{\textcolor{red}} %% début du document \begin{document} % \begin{frame} Mon opération sera ici ! \end{frame} % \end{document}

Ce qui donne une fois compilé avec pdflatex la présentation suivante :

Intégration de l'opération dans Beamer

Il n'y a plus qu'à demander à Beamer de mettre sur la même page, une étape puis une autre etc. en superposant évidemment parfaitement pour éviter tout « saut » mal venu ; c'est ici qu'il faut penser à notre retenue : elle doit toujours être présente (même s'il n'est pas nécessaire de l'afficher, il faut la dessiner en blanc avec la bonne taille) pour que notre opération ne saute pas lorsqu'elle apparaît.

Beamer dispose de tout un lot de fonctionnalités d'affichage ou de non affichage sur la page ; qui plus est, il n'est pas nécessaire de connaître le numéro de notre transparent, Beamer le calcule seul. Je vais utiliser la commande \only<+>{mon operation}

\only permet d'être exclusif sur l'affichage avec le numéro de transparent qui va suivre. Ici le numéro de transparent est +, il s'agit d'une incrémentation automatique du numéro.

Voici donc à quoi ressemblera l'étape 1 :
\only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc]{128.05}{43.1}}

Raffinements et découverte frame par frame de l'opération

Voilà, tout est fin prêt mais...un peu petit pour une présentation.
Je vais donc imposer un [12pt] en option de la classe beamer et un \Huge pour avoir quelque chose de vraiment grand.
Nous devons alors refaire calculer les espacements par xlop et en plus j'impose un columnwidth=2ex pour encore mieux espacer. De plus vous avez sans doute noter que, par défaut, le séparateur décimal est le point alors cela nécessite un petit réglage supplémentaire, ainsi je fais finalement :

\begin{frame}[t] \Huge \opset{decimalsepsymbol={,},columnwidth=2ex,lineheight=\baselineskip}% ...

Pour conclure, je centre ce qui suit avec un environnement center

Voilà donc le code final :

\documentclass[12pt]{beamer} \usepackage[frenchb]{babel} \usepackage{aeguill} \usepackage{xlop} \usepackage{xcolor} \newcommand{\blanc}{\textcolor{white}} \newcommand{\noir}{\textcolor{black}} \newcommand{\rouge}{\textcolor{red}} \begin{document} \begin{frame} \Huge \opset{decimalsepsymbol={,},columnwidth=2ex,lineheight=\baselineskip}% \begin{center} \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false,%% operandstyle.1.-2=\rouge,operandstyle.2.-2=\rouge,resultstyle.-2=\rouge]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false,%% operandstyle.1.-1=\rouge,operandstyle.2.-1=\rouge,resultstyle.-1=\rouge]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\rouge,deletezero=false,%% operandstyle.1.1=\rouge,operandstyle.2.1=\rouge,resultstyle.1=\rouge]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\rouge,deletezero=false,%% operandstyle.1.2=\rouge,operandstyle.2.2=\rouge,resultstyle.2=\rouge]%% {128.05}{43.1}}%% %% \only<+>{\opadd[resultstyle=\blanc,carrystyle=\small\blanc,deletezero=false,%% operandstyle.1.3=\rouge,operandstyle.2.3=\rouge,resultstyle.3=\rouge]%% {128.05}{43.1}}%% %% \only<+>{\opadd[carrystyle=\small,deletezero=false]{128.05}{43.1}}%% \end{center} \end{frame} \end{document}

Le fichier final est joint à cet article.

Quelques liens

Accord-cadre Microsoft France / Ministère de l'Education nationale du 18 décembre 2003, la réaction de Scidéralle.

Olivier Duquesne (DaffyDuke) — 2004-04-28T14:12:15Z

- Transition vers le Libre...

Production de courbes en environnement LaTeX

David Cobac — 2002-12-16T10:25:37Z

Introduction

Pour produire des images avec LaTeX, il existe de nombreuses possibilités dont l'intégration dans le code
source même de LaTeX. Mais souvent, on utilise des logiciels externes pour illustrer les documents. LaTeX nous
impose un format unique d'image : l'EPS (Encapsulated PostScript). Cela peut sembler restrictif mais en
définitive, cela permet d'unifier toutes les documents produits.
L'extension graphicx autorise avec la commande \includegraphics de manipuler les
images au format EPS et metapost de manière assez aisée, permettant le redimensionnement absolu ou relatif, la rotation,
etc.
Néanmoins, il peut être intéressant de produire une figure dans le code source LaTeX ne serait-ce que pour
y intégrer sans difficulté du code LaTeX et assurer ainsi une harmonie parfaite entre le texte et l'image.
Voici donc une petite présentation de quelques outils produisant des courbes de fonctions dans ou hors
code source.

Intégration dans le code source

PsTricks

Le leader incontesté dans ce domaine est l'extension pstricks. Ses possibilités sont
tellement étendues qu'il est impossible ici de citer tout ce qu'il peut faire. Son inconvénient
majeur est le suivant : il produit du code PostScript donc non visualisable dans un afficheur dvi
traditionnel.

PsTricks est un ensemble homogène d'extensions diverses. Ici l'extension appelée pour intégrer des courbes
s'appelle pst-plot ; l'appel de cette extension charge automatiquement l'extension commune
pstricks.

Nous définissons notre tracé dans un environnement pspicture analogue de l'environnement
picture qui initialise, à chaque appel, les paramètres par défaut de pstricks.

Pour tracer des courbes, il nous faut rentrer une équation.
Pstricks utilise une syntaxe
particulière (celle du PostScript tout simplement) qui ravira les amateurs de calculatrices HP : ce
langage est basé sur une "pile" voici les syntaxes des opérations basiques :

Nom PS	Sign.	Utilisation	Résultat
add	+	2 3 add	5
div	/	6 2 div	3
mul	x	2 3 mul	6
sub	-	2 3 sub	-1
exp	-	2 3 exp	8

PostScript définit aussi les opérateurs :
– neg l'opérateur unaire de signe ;
– abs la valeur absolue ;
– ln et log les logarithmes respectivement néperien et à base 10 ;
– sin et cos désignent les sinus et cosinus d'un angle exprimé en degrés.

Notons que vous devrez calculer vous-même la valeur de la tangente en divisant le sinus par
le cosinus, car elle est indéfinie. Pour en finir avec
les lignes trigonométriques, remarquons l'opérateur binaire atan qui renvoie un angle en
degrés (c'est-à-dire l'angle dont la tangente est le quotient du premier sur le second).

Notons aussi l'existence de idiv et mod qui désignent respectivement le quotient et le reste
dans une division euclidienne. Des opérateurs d'arrondis ou de troncature sont définis mais leur
utilisation dans notre cadre reste très limité.

N'oublions pas les commandes : dup qui copie le contenu de la pile,
exch qui échange les lignes 1 et 2 de la pile, etc. Pour compléter ces informations, consultez
la liste des opérateurs
PostScript.

Pour finir, voici quelques tracés de courbes :
– exemple 1 : une courbe paramétrée

\begin{pspicture}(7.2cm,7.2cm) \rput(3.6,3.6){ % le repère \psset{xunit=3cm,yunit=3cm} \psaxes{->}(0,0)(-1.2,-1.2)(1.2,1.2) \rput(0.05,-0.1){$0$} % le tracé \parametricplot[plotpoints=200,linecolor=red]{0}{360}{t 2 mul sin 3 t mul cos} % la légende \rput(.3,-.7){Courbe de Lissajous% $\left\{\begin{array}{ll}x(t)=\sin(2t)\\y(t)=\cos(3t)\end{array}\right.$% } } \end{pspicture}

Nous définissons les unités pour la figure avec la commandes \psset et les mots-clés
xunit et yunit. Notre courbe de Lissajous étant incluse dans un carré de côté 2 centré sur l'origine, on prendra les valeurs de x dans l'intervalle [-1,2 ;1,2].

La commande \parametricplot permet de dessiner une courbe paramétrée. Ici, j'ai choisi de la
tracer avec 200 points (on aurait pu inclure cette option dans le \psset et ce serait devenu
une option globale des tracés), le paramètre t variant de 0 à 360 degrés.

On remarquera l'absence de séparation entre x(t) et y(t) dans leur définition,
le travail par pile produira ici deux équations.

Pour conclure, le point origine du repère est normalement le coin inférieur gauche, ce qui aurait centré
notre figure sur ce point-là, sans l'intervention d'une petite image par translation des tracés grâce à la
commande \rput ; cette même commande est utilisée pour insérer un texte. Ce dernier est centré,
par défaut, sur le point dont les coordonnées sont données en arguments.

– exemple 2 : une courbe de fonction

Prenons une fonction trigonométrique : x|—>sin(x)/x.

\begin{pspicture}(7cm,8cm) \rput(3.5,2.5){ % le repère \psset{xunit=.25cm,yunit=4cm,plotpoints=200} \psaxes[Dx=3,Dy=.5]{->}(0,0)(-13,-.6)(13,1.3) \rput(-1,-0.05){$0$} % le tracé \psplot[linewidth=.1mm]{-13}{13}{x 180 mul 3.14159 div sin x div} } \rput[l](0,7){$\displaystyle x\longmapsto \frac{\sin x}{x}$} \end{pspicture}

Ici, l'enchaînement est le même, avec la conversion en radians pour la fonction sinus. Bien sûr le
dénominateur lui ne sera pas converti.

– exemple 3 : une illustration de cours

Une petite illustration des fonctions de référence (non trigonométriques) sur l'intervalle [-1 ;1].

\begin{pspicture}(10cm,8cm) \rput(3.6,4){ % le repère \psset{xunit=3cm,yunit=3cm} \psaxes{->}(0,0)(-1.2,-1.2)(1.2,1.2) % les axes (origine) (coin_inf_gauche) (coin_sup_droit) \rput(0.05,-0.1){$0$} % les tracés \psplot[linestyle=dotted]{-1}{1}{x} % fonction identité \psplot[doubleline=true]{-1}{1}{x 2 exp}	% fonction carré \psplot[linestyle=dashed]{-1}{1}{x 3 exp}	% fonction cube \psplot[linecolor=red]{0}{1}{x sqrt} % fonction racine carrée % la légende \psline[linestyle=dotted]{-}(1.3,1)(1.5,1)\rput[l](1.6,1){$x\longmapsto x$} \psline[doubleline=true]{-}(1.3,0.9)(1.5,0.9)\rput[l](1.6,0.9){$x\longmapsto x^2$} \psline[linestyle=dashed]{-}(1.3,0.8)(1.5,0.8)\rput[l](1.6,0.8){$x\longmapsto x^3$} \psline[linecolor=red]{-}(1.3,0.7)(1.5,0.7)\rput[l](1.6,0.7){$x\longmapsto \sqrt{x}$} } \end{pspicture}

Contrairement aux exemples identiques traités dans la suite de l'article avec l'extension
mfpic et metapost, j'ai tracé la courbe de la fonction carré avec un double
trait, option directement accessible en paramètre qui, à ma connaissance n'existe pas avec les autres mais
qui pourrait faire sans doute l'objet d'une macro.

mfpic

Mfpic est une sorte de metapost embarqué, il permet d'intégrer en ligne du code
metafont et définit lui-même des commandes pour tracer des courbes. Cela peut sembler
génialement intéressant mais la procédure de mise en place n'est pas des plus faciles ; en effet, à partir
du code mfpic que vous saisissez, la compilation LaTeX produit le fichier metafont
correspondant. Il faut donc compiler ce nouveau fichier avec metafont de telle sorte que soit
produit un fichier de métriques de police tfm, puis compiler le fichier gf produit afin de créer l'image
de la police elle-même : le fichier pk. Votre image est donc intégrée comme une police dans le
document (ce qui ne nous oblige donc pas de visionner un fichier ps car Le fichier dvi intégrera votre image).

Pour utiliser mfpic, je l'ai téléchargé depuis Internet sur ctan, j'ai créé un
répertoire mfpic dans /usr/share/texmf/tex/latex où j'y ai placé les fichiers
sty et tex. J'ai ensuite copié le fichier grafbase.mf dans le répertoire
/usr/share/texmf/metafont/misc car ces fichiers sont nécessaires à la compilation par
metafont.

Notons que nous pouvons définir à l'instar de la variable d'environnement
TEXINPUTS, les variables MFINPUTS et MPINPUTS. Elles permettent aux
compilateurs associées de metafont et de metapost de trouver les fichiers précédement cités dans les bons répertoires.

Pour finir, voici une session :

– première compilation LaTeX

bash-2.05$ latex essai_mfpic.tex This is TeX, Version 3.14159 (Web2C 7.3.1) (essai_mfpic.tex LaTeX2e <2000/06/01> Babel  and hyphenation patterns for american, french, nohyphenation, loa ded. (/usr/share/texmf/tex/latex/base/article.cls Document Class: article 2000/05/19 v1.4b Standard LaTeX document class (/usr/share/texmf/tex/latex/base/size10.clo)) (/usr/share/texmf/tex/latex/mfpic/mfpic.sty (/usr/share/texmf/tex/latex/mfpic/mfpic.tex)) No file essai_mfpic.aux. Underfull \hbox (badness 10000) in paragraph at lines 5--6 MFpic: No file essai_mfpic.tfm . MFpic: Don't forget to process essai_mfpic.mf! MFpic: (Apply metafont to essai_mfpic.mf, then gftopk to the resulting gf file. ) MFpic: Then reprocess this file (essai_mfpic). [1] (essai_mfpic.aux) ) (see the transcript file for additional information) Output written on essai_mfpic.dvi (1 page, 432 bytes). Transcript written on essai_mfpic.log.

– compilation metafont

bash-2.05$ mf essai_mfpic.mf This is METAFONT, Version 2.7182 (Web2C 7.3.1) (essai_mfpic.mf (/usr/share/texmf/metafont/misc/grafbase.mf MFpic version 0.5.0 beta, 2001/10/30 ) [1] ) Font metrics written on essai_mfpic.tfm. Output written on essai_mfpic.360gf (1 character, 1784 bytes). Transcript written on essai_mfpic.log.

– création de la police (pour ceux qui s'étonne de la résolution employée j'ai encore une vieille mais
très avantageuse Canon BJ-10ex... Bon, il est vrai qu'utiliser LaTeX avec une définition aussi faible est
un crime de lèse-majesté).

bash-2.05$ gftopk essai_mfpic.360gf

– deuxième compilation LaTeX

bash-2.05$ latex essai_mfpic.tex This is TeX, Version 3.14159 (Web2C 7.3.1) (essai_mfpic.tex LaTeX2e <2000/06/01> Babel  and hyphenation patterns for american, french, nohyphenation, loa ded. (/usr/share/texmf/tex/latex/base/article.cls Document Class: article 2000/05/19 v1.4b Standard LaTeX document class (/usr/share/texmf/tex/latex/base/size10.clo)) (/usr/share/texmf/tex/latex/mfpic/mfpic.sty (/usr/share/texmf/tex/latex/mfpic/mfpic.tex)) (essai_mfpic.aux) Underfull \hbox (badness 10000) in paragraph at lines 5--6 MFpic: Don't forget to process essai_mfpic.mf! MFpic: (Apply metafont to essai_mfpic.mf, then gftopk to the resulting gf file. ) MFpic: Then reprocess this file (essai_mfpic). [1] (essai_mfpic.aux) ) (see the transcript file for additional information) Output written on essai_mfpic.dvi (1 page, 372 bytes). Transcript written on essai_mfpic.log.

– visualisation du binaire

bash-2.05$ xdvi essai_mfpic.dvi

OUF ! on pourra aisément automatiser ces tâches pour faciliter l'utilisation de cette extension.
Maintenant regardons un peu sur les mêmes exemples que précédemment ce que produit l'extension.
Voici le document source pour les trois exemples précédents avec mfpic.

\documentclass{article} \usepackage{mfpic} \begin{document} \opengraphsfile{essai_mfpic} \mfpicunit=1cm \centering \fbox{ \begin{mfpic}[3][3]{-1.2}{1.2}{-1.2}{1.2} % le repère \axes \xmarks{-1,1} \ymarks{-1,1} \tlabel[tl](0.03,-0.03){O} \tlabel[tc](-1,-0.03){$-1$}\tlabel[tc](1,-0.03){1} \tlabel[cl](0.03,-1){$-1$}\tlabel[cl](0.03,1){1} % le tracé \parafcn{0,360,1}{(sind 2t,cosd 3t)} % la légende \tlabel[cc](.3,-.7){Courbe de Lissajous% $\left\{\begin{array}{ll}x(t)=\sin(2t)\\y(t)=\cos(3t)\end{array}\right.$% } \end{mfpic} }\\[.5cm] \fbox{ \begin{mfpic}[.25][4]{-13}{13}{-.6}{1.3} % le repère \axes \xmarks{-12,-9,-6,-3,0,3,6,9,12} \ymarks{-.5,.5,1} \tlabel[tl](0.5,-0.03){O} \tlabel[tc](-12,-0.03){$-12$}\tlabel[tc](12,-0.03){12} \tlabel[tc](-9,-0.03){$-9$}\tlabel[tc](9,-0.03){9} \tlabel[tc](-6,-0.03){$-6$}\tlabel[tc](6,-0.03){6} \tlabel[tc](-3,-0.03){$-3$}\tlabel[tc](3,-0.03){3} \tlabel[cl](0.5,-.5){$-0,5$}\tlabel[cl](0.5,1){1} \tlabel[cl](0.5,0,5){$0,5$} % le tracé \function{-13,13,.13}{sind(x*180/3.14159)/x} % la légende \tlabel[tl](-13,1.1){$\displaystyle x\longmapsto \frac{\sin x}{x}$} \end{mfpic} } \fbox{ \begin{mfpic}[3][3]{-1.2}{1.2}{-1.2}{1.2} % le repère \axes \xmarks{-1,0,1} \ymarks{-1,1} \tlabel[tl](0.03,-0.03){O} \tlabel[tc](-1,-0.03){$-1$}\tlabel[tc](1,-0.03){1} \tlabel[cl](0.03,-1){$-1$}\tlabel[cl](0.03,1){1} % les tracés \dotted\function{-1,1,.1}{x} \pen{1bp}\function{-1,1,.1}{x**2} \pen{.5pt} \dashed\function{-1,1,.1}{x**3} \function{0,1,.1}{sqrt(x)} % la légende \dotted\lines{(1.3,1),(1.5,1)}\tlabel[l](1.6,1){$x\longmapsto x$} \pen{1bp}\lines{(1.3,0.9),(1.5,0.9)}\tlabel[l](1.6,.9){$x\longmapsto x^2$} \pen{.5pt} \dashed\lines{(1.3,0.8),(1.5,0.8)}\tlabel[l](1.6,.8){$x\longmapsto x^3$} \lines{(1.3,0.7),(1.5,0.7)}\tlabel[l](1.6,.7){$x\longmapsto \sqrt{x}$} \end{mfpic} } \closegraphsfile \end{document}

Dès le départ, un fichier que j'ai nommé essai_mfpic est ouvert en écriture, c'est celui-ci
qui va contenir après la première compilation le code metafont à compiler. Il est
naturellement fermé à la fin du source LaTeX.
On remarque l'absence cruelle de couleur, mais mfpic dispose d'une commande
\usemetapost pour produire non pas du code metafont mais du code
metapost qui sera donc à compiler avec ce dernier et non plus metafont.

Bien entendu, on aura accès à plus de paramètres et notamment à la couleur, mais les figures produites ne
seront visualisables qu'avec un visualiseur acceptant le format PostScript.

Le positionnement des étiquettes peut se faire à l'aide de 2 paramètres qui définissent respectivement la
position verticale (b pour bottom (bas), c pour center (centré), l pour left (gauche) et r pour right
(droite)) et la position horizontale (définie de la même manière).

La commande function prend trois paramètres : l'abscisse de départ, l'abscisse d'arrivée et
le pas pour parcourir cet intervalle. Le reste est très compréhensible.

Mon impression

– PsTricks est vraiment un outil très puissant, jetez un coup d'oeil à la documentation et vous
serez ébloui par toutes ces figures et ces graphiques. La nécessité de devoir visualiser en PostScript
n'est pas très gênante pour moi car je ne visualise jamais mon dvi : j'emploie toujours la commande :

dvips monfichier.dvi -o

pour finalement visualiser avec gv.

– L'extension mfpic est remarquable. Dessiner une courbe de fonction est d'une simplicité
inégalable. En revanche, je déteste la complexité (certes relative) de la compilation. J'avoue préférer
tracer directement avec metapost. Ce n'est alors plus intégré dans le source LaTeX mais
plutôt que d'apprendre des commandes pour construire un fichier metafont ou
metapost autant apprendre le langage lui-même...

Intégration hors code source

L'intégration hors code source se fait avec la commande \includegraphics de l'extension
graphicx, par exemple :

\includegraphics{monfichier.eps}

metapost

Je vous propose tout simplement de reprendre les exemples précédents en créant trois figures. Ici j'ai
utilisé du code LaTeX pour mes étiquettes dans metapost alors que par défaut,
metapost utilise TeX pour compiler... J'ai donc attribué la valeur latex à la variable d'environnement TEX.

export TEX=latex

Ensuite dans mon code source metapost, j'ai inséré au début et à la fin les déclarations
habituelles des sources latex pour que les étiquettes soient correctement compilées par LaTeX.

Pour finir, les étiquettes utilisant LaTeX voit leur contenu (dans le source) encadré par les marqueurs
btex et etex.

verbatimtex \documentclass{article} \begin{document} etex beginfig(1); path axe,taquet,courbe; u=3cm; % les axes axe=(-1.2u,0)--(1.2u,0); drawarrow axe; drawarrow axe rotated 90; % les marques for i=-1,1 : draw (i*u,-.5mm)--(i*u,.5mm); label.bot(decimal(i),(i*u,-1mm)); draw (-.5mm,i*u)--(.5mm,i*u); label.lft(decimal(i),(0,i*u)); endfor label.llft("O",(-.5mm,-.5mm)); % le calcul de la courbe k=0; for i=1 upto 200 : % on divise en 200 valeurs les valeurs de 0 à 360 monangle:=(i-1)*360/199; x:=sind(2*monangle);y:=cosd(3*monangle); % si ce n'est pas le premier point on ajoute au chemin précédent if i=1: courbe=(x*u,y*u) else: courbe:=courbe--(x*u,y*u) fi; endfor % le tracé de la courbe draw courbe withcolor red; % l'étiquette label(btex Courbe de Lissajous% $\left\{\begin{array}{ll}x(t)=\sin(2t)\\y(t)=\cos(3t)\end{array}\right.$% etex,(.3u,-.7u)); endfig; beginfig(2); path axe[],courbe; ux=.25cm;uy=4cm; % les axes axe0=(-13ux,0)--(13ux,0); axe1=(0,-.6uy)--(0,1.3uy); drawarrow axe0; drawarrow axe1; % les marques for i=-12 step 2 until 12 : draw (i*ux,-.5mm)--(i*ux,.5mm); if i<>0 : label.bot(decimal(i),(i*ux,-1mm)) else : label.llft(btex O etex,origin) fi; endfor for i=-0.5,0.5,1 : draw (-.5mm,i*uy)--(.5mm,i*uy); label.lft(decimal(i),(0,i*uy)); endfor % le calcul de la courbe for i=1 upto 200 : % on divise en 200 valeurs les valeurs de --13 à 13 x:=-13+(i-1)*26/199; y:=sind(x*180/3.14159)/x; % si ce n'est pas le premier point on ajoute au chemin précédent if i=1: courbe=(x*ux,y*uy) else: courbe:=courbe--(x*ux,y*uy) fi; endfor % le tracé de la courbe draw courbe withpen pencircle scaled .1mm; % l'étiquette label.lrt(btex $\displaystyle x\longmapsto {\sin x \over x}$ etex,(-13ux,1.3uy)); endfig; beginfig(3); path axe,taquet,courbe[],leg; u:=3cm; % les axes axe=(-1.2u,0)--(1.2u,0); drawarrow axe; drawarrow axe rotated 90; % les marques for i=-1,1 : draw (i*u,-.5mm)--(i*u,.5mm); label.bot(decimal(i),(i*u,-1mm)); draw (-.5mm,i*u)--(.5mm,i*u); label.lft(decimal(i),(0,i*u)); endfor label.llft("O",(-.5mm,-.5mm)); % le calcul des courbes for i=1 upto 200 : % on divise en 200 valeurs les valeurs de -1 à 1 x:=-1+(i-1)*2/199; for j=1 upto 3 : y:=x**j; if i=1: courbe[j]=(x*u,y*u) else: courbe[j]:=courbe[j]--(x*u,y*u) fi; endfor; if i=101: courbe4=(x*u,sqrt(x)*u) fi; if i>100: courbe4:=courbe4--(x*u,sqrt(x)*u) fi; endfor % le tracé de la courbe draw courbe[1] dashed withdots; draw courbe[2] withpen pencircle scaled 1bp; draw courbe[3] dashed evenly; draw courbe[4] withcolor red; % la légende leg=(1.3u,u)--(1.5u,u); label.rt(btex $x\longmapsto x$ etex,(1.6u,u)); draw leg dashed withdots; label.rt(btex $x\longmapsto x^2$ etex,(1.6u,.9u)); draw leg shifted (0,-.1u) withpen pencircle scaled 1bp;; label.rt(btex $x\longmapsto x^3$ etex,(1.6u,.8u)); draw leg shifted (0,-.2u) dashed evenly; label.rt(btex $x\longmapsto \sqrt x$ etex,(1.6u,.7u)); draw leg shifted (0,-.3u) withcolor red; endfig; verbatimtex \end{document} etex end

La grande différence avec les solutions précédemment proposées est qu'ici, vous devez TOUT faire, au
risque de rebuter les adeptes de la facilité, mais l'avantage est de pouvoir maîtriser beaucoup plus de
choses.

On notera deux aspects intéressants dans le code :
– l'inclusion de code LaTeX dans les étiquettes (cf. remarque du début) ;
– l'utilisation d'un test systématique pour établir nos courbes. En effet, celles-ci sont déclarées comme
étant de type path, si nous essayons de faire sans, nous coderions tout simplement, quelque chose du genre :

courbe:=courbe--(x*ux,y*uy);

Mais voilà au premier appel la variable courbe n'a pas de valeur définie. Donc pour
commencer la courbe, on teste à l'aide d'un compteur s'il s'agit du premier point calculé,
auquel cas on attribue à la variable courbe cette valeur de type pair, le code devient donc :

if i=1: courbe=(x*ux,y*uy) else: courbe:=courbe--(x*ux,y*uy) fi;

où i est le compteur dans la boucle de calcul.

gnuplot

Connaissant fort mal gnuplot, je ne vous présente ici que quelques aspects bien simples de ce logiciel.

gnuplot est un logiciel de tracés de courbes scientifiques. Il permet en mode interactif (via la ligne de
commande) de définir le style des courbes, mais aussi de préciser le type de sortie voulu : sortie
écran, sortie fichier au format PNG ou autre, sortie en code LaTeX (environnement picture), sortie pstricks
(environnement pspicture), etc.

Le mode interactif est certes intéressant, mais on préférera sans doute le passage par un fichier. Par
exemple, j'ai constitué, pour la première courbe, un fichier de commandes gnuplot que j'ai appelé
'figure1.gnu'. Pour évaluer son contenu, je vais appeler la commande gnuplot puis à l'invite interactive,
je vais saisir la commande :

load 'figure1.gnu'

Pour paramétrer la sortie, il faut changer la valeur de la variable term. Par défaut celle-ci
est fixée à X11, c'est-à-dire que les tracés se feront dans une fenêtre de X11 que gnuplot
affichera. Pour générer une sortie différente, par exemple une sortie LaTeX, on écrira :

set term latex

Dans ce cas, la sortie (en code LaTeX) se fera sur la sortie standard, donc sans doute la console
elle-même. Pour diriger ce flux vers un fichier, il suffit de changer la valeur de la variable
outout, par exemple :

set output figure1.tex

Voilà l'ensemble des sorties possibles :

aed512, aed767, aifm, bitgraph, cgm, corel, dumb, dxf,
eepic, emtex, epson-180dpi, epson-60dpi,
epson-lx800, fig, gif, gpic, hp2623a, hp2648, hp500c, hpdj,
hpgl, hpljii, hppj, imagen,
kc-tek40xx, km-tek40xx, latex, mf,
mif, mp, nec-cp6, okidata,t
pbm, pcl5, png, postscript,
pslatex, pstex, pstricks, qms,
regis, selanar, starc, table,
tandy-60dpi, tek410x, texdraw, tgif,
tkcanvas, tpic, vttek, x11,
xlib.

On y trouvera notamment emtex, latex, mf
mp, pslatex, pstex, pstricks, tex et texdraw.

Pour produire les images de cet article, j'ai demandé une sortie png. Bien entendu, dans les exemples, il
s'agit de les inclure dans un document LaTeX. J'ai donc demandé une sortie latex (fichier qui porte l'extension .tex). Il suffira par la suite d'intégrer le
fichier dans le code source LaTeX en utilisant :

\input figure1.tex

– exemple 1

set term latex set output 'figure1.tex' set parametric set noborder set zeroaxis set xtics axis 1 set ytics axis 1 set xrange [-1.2:1.2] set yrange [-1.2:1.2] set samples 200 plot [0:2*pi] sin(2*t),cos(3*t) notitle

– exemple 2

set term latex set output 'figure2.tex' set noborder set zeroaxis set xtics axis 3 set ytics axis .5 set xrange [-13:13] set yrange [-.6:1.3] set samples 200 plot sin(x)/x notitle lw 1

– exemple 3

set term latex set output 'figure3.tex' set noborder set zeroaxis set xtics axis 1 set ytics axis 1 set xrange [-1.2:1.2] set yrange [-1.2:1.2] set samples 200 plot [-1:1] x notitle, x**2 notitle,x**3 notitle,sqrt(x) notitle

Je ne développe pas les possibilités d'intégration de code LaTeX dans les images. Je ne les connaîs pas
mais je sais qu'elles existent.

Les autres

Gnuplot possède aussi des capacités de tracés de surfaces et courbes en dimension 3. Pour les allergiques à gnuplot, il existe quelques front-ends sur Internet.

Pour finir, on trouvera sur Internet nombre de traceurs de courbes qui exportent en EPS.

Netographie

– pstricks ;
– mfpic ;
– metapost ;
– gnuplot.

Création de mng (images animées) avec metapost

David Cobac — 2002-12-09T21:02:01Z

Dans le programme de seconde, on demande aux élÚves d'afficher la courbe de la fonction sinus. Avec metapost et ImageMagik, rien de plus facile...

Petits rappels sur metapost

Nous avions découvert comment produire des figures géométriques dans l'article "Une approche de metapost", nous avions
vu aussi qu'un fichier source pouvait contenir plusieurs définitions de figures et donc engendrer
plusieurs fichiers d'images au format PostScript.

On se souvient aussi que les variables sont par défaut globales et donc se conservent d'une image à
l'autre (à moins qu'on invoque les commandes de déclarations de type sur elles).

Objectif

Dans le programme de seconde, on demande aux élèves d'afficher la courbe de la fonction sinus
(par exemple). Je vous propose donc d'élaborer une animation où on voit la courbe de la fonction se
dessiner en même temps que le déplacement d'un point sur un cercle trigonométrique le tout sur une
période, c'est-à-dire 2*pi.

Code commenté metapost

% metapost travaille en degrés donc nous définissons % une petite fonction de conversion en radian vardef conversion (expr monangle) = monangle*3.14159265359/180 enddef; beginfig(1); pair O,O'; path cercle,axe[]; picture FigureInit; rayon=2cm; O=origin; % la figure de gauche : le cercle trigo cercle=fullcircle scaled (2*rayon); axe0=(0,-1.1*rayon)--(0,1.1*rayon); axe1=(-1.1*rayon,0)--(1.1*rayon,0); pickup pencircle scaled .5bp; draw cercle; for i=0,1 : drawarrow axe[i]; endfor % la figure de droite : le repère pour tracer la fonction O'=(rayon+1cm,0); axe2=axe0 shifted O'; axe3=O'shifted (-.5cm,0)--O' shifted (6.5*rayon,0); for i=2,3 : drawarrow axe[i]; endfor % on enregistre cette figure FigureInit=currentpicture; endfig; % Déclaration de la courbe commune à toutes les figures. path courbeSinus; % Celle-ci commence à l'origine du repère courbeSinus=O'; % Nombre de figures à créer % Plus le nombre est grand, plus grande sera la précision % de la courbe. jmax=20; % Boucle des figures for j=1 upto jmax : beginfig(0+j); pair Mcercle,Maxe,Mcourbe; % je retrace la figure 1 (le fond) draw FigureInit; % le calcul de l'angle en degrés % 360/(jmax-1) désigne l'angle de rotation d'incrément % (on retranche 1 pour démarrer l'angle à 0) monangle:=(360/(jmax-1))*(j-1); % pour mettre le point sur la courbe, son abscisse % doit être en radian (c'est plus simple vu que j'ai l'unité % rayon déjà toute prête) % Le point Maxe est le projeté orthogonal de Mcercle sur l'axe % des abscisses dans le repère du cercle. Mcercle=(cosd(monangle)*rayon,sind(monangle)*rayon); Maxe=(cosd(monangle)*rayon,0); Mcourbe=(conversion(monangle)*rayon,sind(monangle)*rayon) shifted O'; draw Mcercle--Maxe; draw Mcercle withpen pencircle scaled 4 bp withcolor red; % La courbe s'allonge proportionnellment à j courbeSinus:=courbeSinus--Mcourbe; draw courbeSinus withcolor .5red; draw Mcourbe withpen pencircle scaled 4 bp withcolor red; endfig; endfor end

Vous remarquerez qu'ici nous écrasons la figure 1 dès j=1, cela nous permet
d'éviter l'apparition de figures parasites à éliminer après compilation par metapost ; la figure 1 ne
servant qu'à initialiser la variable FigureInit, notre fond.

Production de l'animation

La compilation du code nous fournit donc 20 fichiers images ; mon fichier source s'appelant Sinus.mp, la compilation a fourni : Sinus.1, Sinus.2, etc. jusqu'à Sinus.20.

Pour convertir ces images en une seule image animée, nous allons utiliser le logiciel ImageMagick et sa commande magique (évidemment) convert.

La lecture de la page de manuel de cette commande vaut le détour, le nombre de formats supportés est incroyable.

La commande convert appliquée directement aux fichiers images metapost fonctionne (n'oublions pas que les formats d'images sont (quasiment) des fichiers PostScript) :

convert -delay 10 Sinus.* Sinus.mng

Hélas, l'ordre des figures n'est pas respecté !!

On a donc recours soit à la commande exhaustive :

bash-2.05$ convert -delay 10 Sinus.1 Sinus.2 Sinus.3 Sinus.4 Sinus.5 Sinus.6 Sinus.7 Sinus.8 Sinus.9 Sinus.10 Sinus.11 Sinus.12 Sinus.13 Sinus.14 Sinus.15 Sinus.16 Sinus.17 Sinus.18 Sinus.19 Sinus.20 Sinus.mng

soit au renommage des fichiers Sinus.1 jusqu'à Sinus.9 en Sinus.01 à Sinus.09 (merci Fred) ce qui nous assurera le respect de l'ordre des figures grâce à la commande :

convert -delay 10 Sinus.* Sinus.mng

Puis on visualise le résultat avec la commande animate d'ImageMagick :

bash-2.05$ animate Sinus.mng

ou dans un navigateur Internet supportant les fichiers mng, comme Mozilla.

netographie

http://www.imagemagick.org/

Une approche de metapost

David Cobac — 2002-12-06T14:40:28Z

Avec metapost, insérez des courbes et des graphiques dans vos documents créés avec LaTex. Explications.

A qui s'adresse metapost ?

A l'heure où les logiciels de géométrie dynamique sont pleinement exploitées, en classe, par les élèves, et où bon nombre de documents utilisés par les professeurs sont rédigés avec ces logiciels dits "RIP" (Reconnu
d'Intérêt Pédagogique), il est naturel de se poser la question. Metapost est un logiciel de conception de
dessins et est donc, à ce titre, inutilisable avec des élèves car non visuel.

Metapost est un langage que j'appellerai de "description géométrique" issu du langage metafont. Ce dernier sert
de support à la création de polices utilisables par (La)TeX. Il en reprend la plupart des primitives et
en inclut de nouvelles. De ce fait, metapost est naturellement lié à (La)TeX et donc assure une intégration
parfaite dans cet environnement de travail.

Un fichier, plusieurs images

Dans un fichier source metapost, on peut définir plusieurs figures. Voici la structure du contenu d'un fichier
source :

beginfig(1); ... ... endfig; beginfig(2); ... ... endfig; end

En appelant essaidocclx.mp ce fichier et en le compilant avec la commande mpost essaidocclx.mp, on obtiendra 2 fichiers : essaidocclx.1 et essaidocclx.2 que l'on pourra simplement inclure dans un
document LaTeX en utilisant par exemple le package graphicx :

\includegraphics{essaidocclx.1}
La lecture des premières lignes du fichier essaidocclx.1 dans un éditeur nous apprend que
le fichier produit est au format PostScript :

%!PS %%BoundingBox: -11 -55 203 138 %%Creator: MetaPost

Types en metapost

Plusieurs types de données sont définissables et manipulables avec metapost. Toute variable doit être déclarée avec son type. Une variable non déclarée sera considérée comme du type numeric.

Les principaux types sont :
– numeric : variable numérique signée de -4096 (aussi appelé -infinity) à
4096 (appelée +infinity) ;
– pair : couple de valeurs numériques définissant un point ou un vecteur, ils seront
manipulés comme des affixes (ce qui rend les choses très pratiques) ;
– path : chemin qui pourra être une droite, un cercle ou plus généralement une courbe.
D'autres types existent, nous en rencontreront au fur et à mesure de notre besoin.

La géométrie des transformations

Qui dit géométrie dit transformations géométriques, et sur ce terrain metapost est imbattable.
Il permet tout simplement la définition de toutes les transformations affines !
Certaines sont déjà prédéfinies comme opérateurs binaires telles que :
– shifted : (x,y) shifted (a,b) sera la définition du translaté de vecteur
de coordonnées (a,b) du point (x,y). Bien sûr cet opérateur pourra s'appliquer sur un objet de type path ;
– rotated : (x,y) rotated 35 sera l'image par la rotation d'angle de mesure 35
degrés du point de coordonnées (x,y), là encore cette transformation pourra s'appliquer à d'autres types.

De manière générale, metapost introduit un type transform qui permet de définir les
composantes de la matrice de transformation.

Quelques petites choses avant de commencer

– Metapost permet de placer des points sur une droite définie par deux points avec une notation de
coordonnées barycentriques ; par exemple, la notation .5[A,B], où A et B sont des objets de
type pair, désigne le milieu du segment [AB], la notation .7[A,B] désigne le point M
vérifiant vec(AM)=0,7*vec(AB) ou encore : M=(1-0,7)*A+0,7*B affixement parlant.
– Certains objets de type pair sont prédéfinis, ainsi z0, z1, z2, etc. désignent des pairs
dont les coordonnées sont eux-mêmes prédéfinies x0, x1, x2, etc. et y0, y1, y2, etc.
Cela permet, entre autres, d'éviter d'être obligé de définir des objets de ce type.
– L'instruction draw dessine le chemin qu'on lui donne en argument.
– Une droite entre deux objets de type pair A et B est définie par A--B, le symbole
-- indique simplement que l'on va tracer une ligne droite entre les deux points.Pour tracer un
triangle ABC, on utilisera donc draw A--B--C--A ou encore draw A--B--C--cycle
qui permet de fermer un chemin existant.
– Pour tracer de manière courbe, on utilisera .. à la place de --, bien sûr il existe une infinité de manières de tracer une courbe fermée passant par trois points, par exemple,
metapost fait donc un choix par défaut, on peut le forcer à dessiner un chemin particulier mais ceci dépasse largement le
cadre de notre article.
– Metapost sait travailler avec des inconnues et résoudre des systèmes d'équations linéaires (hé oui, et
rien que pour cela c'est génial !).
– Le mot-clé whatever remplace n'importe quelle valeur numérique non définie et dont la
valeur ne nous intéresse pas (cf. exemple 1).
– Le mot-clé origin désigne l'objet pair de coordonnées (0,0).
– Comme tout langage, metapost permet de construire des boucles, de comparer des valeurs avec des opérateurs de test, d'élaborer des fonctions, etc. (cf. exemples).
– Une instruction en metapost se conclut par un point-virgule.
– A l'instar de LaTeX, le symbole % est utilisée pour les commentaires.

3 exemples commentés

– exemple 1 : la droite d'Euler

Figure classique de géométrie, on va tracer successivement le centre de gravité G, l'orthocentre H et le
centre du cercle circonscrit O d'un triangle ABC.

beginfig(1); pair A,B,C,O,G,H; u=1cm; A=origin;B=(5u,0);C=(2u,3.5u); draw A--B--C--cycle; % définition de O (O-0.5[A,B]) rotated 90=whatever*(A-B); (O-0.5[A,C]) rotated 90=whatever*(A-C); draw O; % définition de G G=2/3[A,0.5[B,C]]; draw G; % définition de H (H-A) rotated 90=whatever*(B-C); (H-B) rotated 90=whatever*(A-C); draw H; endfig;7 end

Nous définissons les coordonnées en centimètres des sommets du triangle, voyez d'ailleurs l'utilisation
d'une variable numérique u (car non déclarée au préalable) comme unité de mesure.
Si nous regardons la définition de O, elle se fait de manière vectorielle, nous indiquons ici que le
vecteur vec(OI) (où I désignerait le milieu de [AB]) est orthogonal au vecteur vec(AB). Bien sûr, cette
seule définition de O ne suffit pas et nous devons encore indiquer une autre orthogonalité pour
définitivement connaître O.

– exemple 2 : carré tournant du document d'accompagnement du programme de la classe de Première S page 47

On part d'un carré de 10 cm de côté. Sur chaque côté, en tournant dans le même sens, on place un point
situé à une distance de 1 cm de chaque sommet du carré. Et on itére.

Nous allons effectuer 10 itérations.

beginfig(1); pair A,B,C,D,tmp; u=1cm;	NbIter=10; A=origin;B=(10u,0);C=(10u,-10u);D=(0,-10u); draw A--B--C--D--cycle; for i=1 upto NbIter : tmp:=A; A:=A+u*(B-A)/abs(B-A); B:=B+u*(C-B)/abs(C-B); C:=C+u*(D-C)/abs(D-C); D:=D+u*(tmp-D)/abs(tmp-D); draw A--B--C--D--cycle; endfor; endfig; end

Remarquons la forme particulière de la boucle for qui avec cette syntaxe impose un incrément de 1.
On remarquera aussi que la définition d'une variable se fait avec le signe d'égalité mais sa redéfinition ou sa réaffectation se fait avec le symbole :=.
La fonction abs s'applique aussi bien à des objets de type numeric qu'à des
objets de type pair et définit... Je vous laisse deviner.

Mais metapost nous offre la fonction unitvector ainsi, on pourrait simplifier nos calculs
en remplaçant : A:=A+u*(B-A)/abs(B-A); par A:=A+u*unitvector(B-A);.

– exemple 3 : Tracé sur [0 ;4] de la fonction x|->6x^2-x^3

beginfig(1); path courbeA,courbeB; u=1cm; % tracé des axes drawarrow (-.5u,0)--(6.5u,0); drawarrow (0,-.5u)--(0,6.5u); % les étiquettes sur les axes for i=0 step 2 until 6 : dotlabel.bot(decimal(i),(i*u,0)); dotlabel.lft(decimal(i*6),(0,i*u)); endfor; % construction de 2 chemins courbeA = courbeB = origin; for i=0 upto 12 : j:=i/2; v:=(6*(j**2)-(j**3))/6; courbeA:=courbeA--(j*u,v*u); courbeB:=courbeB..(j*u,v*u); endfor draw courbeA; draw courbeB withcolor 7red; endfig; end

Dans cet exemple, j'ai tracé deux courbes qui passent par les mêmes points. L'une est tracée à l'aide de segments de droite, l'autre par des segments de courbes (celle en rouge). Remarquons ici la médiocrité de la courbe
rouge qui ne rend pas vraiment compte de la réalité, en effet les tracés de metapost sont faits par des courbes de
Bézier dont il choisit lui-même les points de contrôle (entre deux points réels de la courbe, deux autres points
ont été choisis par metapost). Les courbes de Bézier ne sont pas manifestement toujours les meilleures
approximations polynômiales (cf. polynômes de Bernstein). On préférera augmenter le nombre de points et
tracer de petits segments (finalement comme la calculatrice !).

L'instruction dotlabel permet de dessiner un point et d'y mettre une étiquette (ici dépendant
de i). Attention l'instruction dotlabel.bot(i,(i*u,0)) aurait mis la lettre i partout !!

On remarquera le tracé des axes avec une variante de l'instruction draw et l'utilisation d'un
type non rencontré jusqu'à présent : color.

Macros

metapost autorise la création de macro-commandes, et à l'image de LaTeX permet de les réunir dans un fichier séparée et d'en faire appel avec la commande input au début du fichier.

Deux types de macros sont définissables, le type def et le type vardef.
On utilisera de préférence le type vardef qui permet d'introduire des noms variables
pour les macros. Par exemple, si on veut définir les rotations en donnant leurs angles
dans le nom de la macro, on pourra réaliser une unique macro vardef
qui définit les noms rotation60, rotation120, etc. De plus, ce type de macros
permet avantageusement de définir en son sein des variables locales grâce à l'instruction
save.

Notons que toute variable déclarée dans une macro (hormis les arguments) est globale si on n'utilise pas l'instruction
save ; remarquons aussi que les déclarations de type effacent les valeurs des variables qui avaient été éventuellement définies avec le même nom.

– exemple 1 : quelques points remarquables du triangle

En reprenant l'exemple 1 de figure , il peut être intéressant de pouvoir directement
fixer ces points qui reviennent fréquemment dans nos figures :

vardef centredegravite (expr a,b,c) = ((a+b+c) scaled 1/3) enddef; vardef orthocentre (expr a,b,c) = save $; pair $; ($-a) rotated 90=whatever*(b-c); ($-b) rotated 90=whatever*(a-c); $ enddef; vardef centrecerclecirconscrit (expr a,b,c) = save $; pair $; ($-1/2[a,b]) rotated 90=whatever*(a-b); ($-1/2[a,c]) rotated 90=whatever*(a-c); $ enddef; vardef cerclecirconscrit (expr a,b,c) = save $,p; pair $; path p; $=centrecerclecirconscrit(a,b,c); p=fullcircle scaled (2*abs($-a)) shifted $; p enddef; vardef centrecercleinscrit (expr a,b,c) = save $; pair $; ($-a)=whatever*(b-a) rotated (1/2*(angle(c-a)-angle(b-a))); ($-b)=whatever*(c-b) rotated (1/2*(angle(a-b)-angle(c-b))); $ enddef; vardef cercleinscrit (expr a,b,c) = save I,M,p; pair I,M; path p; I=centrecercleinscrit(a,b,c); ((M-I) rotated 90)=whatever*(b-a); M=whatever[a,b]; p=fullcircle scaled (2*(abs(M-I))) shifted I; p enddef;

Un exemple d'utilisation en reprenant l'exemple 1 :

beginfig(1); pair A,B,C,O,G,H; string s; u=1cm; A=origin;B=(5u,0);C=(2u,3.5u); draw A--B--C--cycle; O=centrecerclecirconscrit(A,B,C); G=centredegravite(A,B,C); H=orthocentre(A,B,C); pickup pencircle scaled 2 bp; for t=O,G,H : draw t; endfor endfig; end

– exemple 2 : un quadrillage paramétrable

Pour les deux derniers exemples, le problème est le même, la macro ne doit pas renvoyer un chemin ou un
vecteur mais bien toute une figure...
Metapost propose ainsi le type picture qui dessine donc l'intégralité d'une figure.
Dans notre cas, l'astuce consiste à l'appel de la macro à :
– 1/ récupérer la figure courante et tout effacer ;
– 2/ dessiner notre quadrillage ou notre cube (cf. exemple 3) ;
– 3/ enregistrer notre figure dans une autre variable ;
– 4/ tout effacer et redessiner la figure avent l'appel de la macro ;
– 5/ la macro renvoie la variable du dessin qu'elle a fait.

Les objets de type picture peuvent être transformés et déformés, on voit
donc l'intérêt d'un tel type.

La figure courante est récupérable grâce à la variable prédéfinie currentpicture.

vardef quadrillage (expr larg,long,espace) = % dessine un réseau espacé larg et long sans unite % espace en cm save fig,qua; picture fig,qua; fig=currentpicture; currentpicture:=nullpicture; for i=0 upto larg : draw (i*espace,0)--(i*espace,long*espace); endfor; for i=0 upto long : draw (0,i*espace)--(larg*espace,i*espace); endfor; qua=currentpicture; currentpicture:=nullpicture; draw fig; qua enddef;

Un exemple d'utilisation :

beginfig(1); picture reseau; u=.5cm; reseau=quadrillage(5,3,u); draw reseau rotated 20 withcolor .5red; endfig; end

– exemple 3 : Dessiner un cube et le nommer

Ce dernier exemple joue avec les variables globales, puisque vous remarquerez que
la commande save n'a pas été utilisé avec le tableau de valeurs sommetCube
ainsi ce tableau une fois défini sort du cadre de notre macro et donc peut-être réutilisé
dans une autre.
L'utilisation du tableau est intéressante à étudier. Les notations
sommetCube[0] et sommetCube0 sont identiques, on conservera la première
écriture dans des boucles par exemple.

vardef cube (expr depart,dimarete) = save fig,cube,chemin; pair sommetCube[]; path chemin; picture fig,cube; fig=currentpicture; currentpicture:=nullpicture; sommetCube0=depart; sommetCube1=sommetCube0 shifted (dimarete,0); (sommetCube3-sommetCube0)=(sommetCube1-sommetCube0) scaled .5 rotated 35; (sommetCube2-sommetCube1)=(sommetCube0-sommetCube1) scaled .5 rotated (-145); for i:=0 upto 3 : sommetCube[i+4]=sommetCube[i] shifted (0,dimarete); endfor draw sommetCube0--sommetCube1--sommetCube2--sommetCube6-- sommetCube5--sommetCube4--cycle; draw sommetCube1--sommetCube5; draw sommetCube0--sommetCube3--sommetCube7 dashed evenly; draw sommetCube2--sommetCube3 dashed evenly; draw sommetCube4--sommetCube7--sommetCube6; cube=currentpicture; currentpicture:=fig; cube enddef; vardef nommecube = label.llft("A", sommetCube0); label.lrt("B", sommetCube1); label.rt("C", sommetCube2); label.lft("D", sommetCube3); label.ulft("E", sommetCube4); label.ulft("F", sommetCube5); label.urt("G", sommetCube6); label.ulft("H", sommetCube7); enddef;

Un exemple d'utilisation :

beginfig(1); picture lecube; pair A,H,F,C; lecube=cube(origin,5cm); draw lecube; nommecube; A=sommetCube0; H=sommetCube7; F=sommetCube5; C=sommetCube2; pickup pencircle scaled 1bp; draw A--F--C; draw H--F; draw A--H--C--cycle dashed evenly; endfig; end

Netographie
– http://melusine.eu.org/syracuse/met...
– http://www.math.jussieu.fr/~zoonek/...
– http://cm.bell-labs.com/who/hobby/M...

Ce n'est, là encore, qu'une approche de metapost.
On pourra dans d'autres articles montrer l'interaction réelle avec (La)TeX, des courbes paramétrées et peut-être aussi la possibilité de faire des mng (images animées).

Utiliser LaTeX

David Cobac — 2002-12-05T17:08:12Z

Vous ne connaissez pas encore LaTex ? qu'à cela ne tienne. Voici un petit article qui pose les bases de ce "langage de mise en forme de texte". Vous y trouverez également un exemple d'utilisation pour créer des en-têtes de devoirs surveillés.

Qu'est-ce que LaTeX ?

LaTeX est un processeur de texte qui a été initialement conçu pour éditer des documents scientifiques.

Pourquoi utiliser LaTeX ?

Les formats des logiciels habituellement utilisés par les enseignants tels que MS-Word
sont propriétaires, ce qui peut empêcher ou contrarier la portabilité des textes
d'une plateforme à une autre ou même d'une version du logiciel à l'autre.
LaTeX constitue, en ce sens, une solution qui assure la pérennité des documents.
De plus, en utilisant LaTeX, on s'affranchit de longues manipulations de la souris pour aller
chercher l'« éditeur d'équations » car ici les formules sont directement intégrées au texte.
Le seul vrai inconvénient de LaTeX est qu'il s'agit d'un langage à balise, comme le HTML. Il nécessite donc dès le départ
une phase d'apprentissage peu intuitive. Mais le résultat est à la hauteur de l'investissement consenti,
peu à peu la puissance du langage s'impose devant sa syntaxe.

Quelques spécificités de LaTeX

LaTeX n'est pas à l'image d'autres logiciels WYSIWYG c'est-à-dire qu'il gère lui-même, à moins qu'on
ne le force à ne pas le faire, les espaces. Ainsi passer à la ligne dans le document source ne fait pas forcément
passer à la ligne dans le document final, ou encore en mettant deux espaces consécutifs, LaTeX n'en
retiendra qu'un.
Pour passer en mode mathématique (c'est-à-dire pour écrire des formules), on encadre la formule
avec le symbole $, pour isoler la formule sur une ligne séparée, on encadre avec le double symbole
$$.

Allure d'un document LaTeX

Voici le fichier source typique d'un document LaTeX, tout ce qui suit sur une ligne le symbole % est
un commentaire qui n'apparaîtra pas dans le document final :

% partie déclarative \documentclass[12pt]{article} \usepackage[latin1]{inputenc} \usepackage[T1]{fontenc} \usepackage[french]{babel} % le document commence réellement ici \begin{document} Une formule que j'aime particulièrement est : $$\sum_{n=1}^{+\infty} \frac{1}{n^2}=\frac{\pi^2}{6}$$ \end{document}

Pour visualiser le résultat de votre frappe, on utilise simplement la commande latex suivie
du nom du fichier source à traiter, ici essaidocclx.tex.

bash-2.05$ latex essaidocclx.tex This is TeX, Version 3.14159 (Web2C 7.3.1) (essaidocclx.tex LaTeX2e <2000/06/01> Babel <v3.7h> and hyphenation patterns for american, french, german, ngerman, i talian, portuges, spanish, swedish, nohyphenation, loaded. (/usr/share/texmf/tex/latex/base/article.cls Document Class: article 2000/05/19 v1.4b Standard LaTeX document class (/usr/share/texmf/tex/latex/base/size12.clo)) (/usr/share/texmf/tex/latex/base/inputenc.sty (/usr/share/texmf/tex/latex/base/latin1.def)) (/usr/share/texmf/tex/latex/base/fontenc.sty (/usr/share/texmf/tex/latex/base/t1enc.def)) (/usr/share/texmf/tex/generic/babel/babel.sty (/usr/share/texmf/tex/generic/babel/frenchb.ldf (/usr/share/texmf/tex/generic/babel/babel.def) ************************************* * Local config file frenchb.cfg used * (/usr/share/texmf/tex/generic/babel/frenchb.cfg))) No file essaidocclx.aux. (/usr/share/texmf/tex/latex/cyrillic/ot2wncyr.fd) [1] (essaidocclx.aux) ) Output written on essaidocclx.dvi (1 page, 704 bytes). Transcript written on essaidocclx.log.

Le compilateur nous prévient des opérations qu'il a effectuées et éventuellement des erreurs rencontrées. Il produit alors trois nouveaux fichiers qui portent le même nom que votre source
mais dont les extensions sont .log (fichier journal de votre compilation), .aux (fichier de renseignement pour le compilateur pour une éventuelle deuxième compilation) et .dvi. Ce dernier est le résultat binaire de votre compilation : votre document final.

Pour afficher son contenu, il suffit d'utiliser un visualisateur pour ce type de documents : xdvi ou kdvi par
exemple.

Logiciels à installer

LaTeX est intégré de manière assez complète avec une distribution (à l'image de GNU/linux) qui contient des outils
de visualisation, de conversion d'un format vers un autre (néanmoins, pour la conversion MSWord-LaTeX, peu de choses
réellement utilisables existent), des polices d'écriture, des logiciels d'écriture de police ou de
conception de figures géométriques, etc.
L'une des plus connue est la distribution tetex (sans doute celle dont vous disposez peut-être même sans le savoir
sur votre système GNU/Linux).
Bien sûr, si vous voulez ajouter de nouveaux fichiers de style .sty ou de nouvelles classes de
documents .cls à votre distribution, deux options s'offrent à vous :
– l'intégrer directement dans la distribution au bon endroit par exemple créer un répertoire dans
/usr/share/texmf/tex/latex et y mettre votre fichier puis mettre à jour la base de données de latex
en tapant la commande texhash ou mktexlsr ;
– l'installer dans votre répertoire /home par exemple dans un répertoire StyLatex et exporter la variable
d'environnement TEXINPUTS (commande export sous bash) :

TEXINPUTS=$TEXINPUTS:~/StyLatex export TEXINPUTS

LaTeX pour les profs

Quel que soit le niveau, le besoin est le même : des en-têtes pour les devoirs, des formatages d'exercices,
etc. De nombreuses solutions existent (sans doute autant que de profs qui utilisent LaTeX), hélas aucune
n'a sans doute été un jour documentée...
Aussi, je propose tout simplement la création d'une macro d'en-tête de devoir surveillé et celle d'une étiquette d'exercices.
Pour créer une macro-commande, l'instruction est \newcommand, sa syntaxe est :

\newcommand{\NomDeLaCommande}[NbreArguments]{codedelacommande}

La partie entre crochets est optionnelle.

– Voici un exemple simple de macro d'en-tête de devoir :

Mon besoin est simple : un en-tête avec "Devoir surveillé n°xx" centré avec les minuscules en capitales
d'imprimerie plus petites que les majuscules, puis à la ligne suivante à gauche la classe et à droite la
date du devoir en italique.
Ma commande va prendre trois arguments : le numéro de devoir, la classe et la date.

\newcommand{\ds}[3]{ \begin{center} \textsc{Devoir Surveillé n°#1}\\ #2\hfill\textit{#3} \end{center} \hrule\vspace{\baselineskip} }

Voilà, c'est tout.
L'instruction \ est un passage à la ligne.
Les #1, #2 et #3 seront remplacés par les arguments dans leur ordre ; tout ce qui se trouve entre
\begin{center} et \end{center} sera centré ; les commandes \textsc et \textit indiquent le style à appliquer
à la police courante ; le \hrule dessine un trait horizontal ; la commande \vspace insére un espace vertical ici de longueur \baselineskip qui est l'espacement de deux lignes dans le contexte courant de telle manière que le texte suivant notre en-tête ne soit pas collé à la ligne tracée précédemment.

– Voici un exemple simple de macro d'exercice :

Le besoin est ici un peu différent puisque c'est LaTeX qui calculera le numero de l'exercice en fonction
de sa position par rapport aux autres (quel luxe !).

Nous allons créer la commande "exercice", nous avons d'abord besoin d'un petit compteur qui s'incrémentera à chaque appel de notre commande "exercice" :

\newcounter{numeroexo} \newcommand{\exercice}{\par\noindent\stepcounter{numeroexo} \hspace{-.25cm}\fbox{\textbf{Exercice \arabic{numeroexo}}}\quad}

Les commandes \newcounter et \stepcounter gèrent la création et l'incrémentation de notre compteur, son
écriture se fait via la commande \arabic qui met sous la forme 1, 2, 3 etc. Vous pouvez définir d'autres formes.

L'instruction \noindent empêche l'indentation automatique ajoutée par LaTeX pour les nouveaux paragraphes, l'instruction \hspace introduit dans notre cas un espace « négatif » horizontal de -0,25 cm, c'est à dire un retrait.
Vient ensuite l'en-tête de l'exercice avec son numéro, le tout encadré (instruction \fbox). On fait alors
suivre notre encadré d'un espace \quad qui correspond à la largeur d'un M majuscule dans la police
courante.

Voici donc notre document :

% partie déclarative \documentclass[12pt]{article} \usepackage[latin1]{inputenc} \usepackage[T1]{fontenc} \usepackage[french]{babel} \newcommand{\ds}[3]{ \begin{center} \textsc{Devoir Surveillé n°#1}\\ #2\hfill\textit{#3} \end{center} \hrule\vspace{\baselineskip} } \newcounter{numeroexo} \newcommand{\exercice}{\par\noindent\stepcounter{numeroexo} \hspace{-.25cm}\fbox{\textbf{Exercice \arabic{numeroexo}}}\quad} % le document commence réellement ici \begin{document} \ds{3}{Seconde 8}{Lundi 2 Décembre} Une formule que j'aime particulièrement est : $$\sum_{n=1}^{+\infty} \frac{1}{n^2}=\frac{\pi^2}{6}$$ \exercice Soit $ABCD$ un tétraèdre régulier. \exercice Soit $f$ la fonction définie sur $]-\infty;0]$ par $f(x)=\sqrt{-x}$. \end{document}

Voici le résultat :

Ce n'est qu'un début.
Bien sûr, vous pouvez créer votre propre fichier de macro-commandes et l'appeler avec la commande :

\usepackage{MonFichierDeMacros}

Ce qui évite d'avoir un en-tête de source démentiel à taper tout le temps.
Les macros données en exemple sont très simples et à ce titre perfectibles, on peut même envisager de
créer un environnement d'exercices plutôt qu'une commande, le contenu de l'exercice se trouverait alors
entre \begin{exercice} et \end{exercice} (cf. commande \newenvironment).

Les éditeurs pour taper le source

Les fans d'emacs seront comblés par le mode AucTeX.
Personnellement, j'utilise Nedit pour lequel a été créé une extension "à la AucTeX".
On trouvera aussi, des possibilités plus WYSIWYG comme LyX.

Conversion en .ps et .pdf

Pour obtenir un document au format PostScript, on utilisera la commande dvips qui permet, à partir du
binaire .dvi, de produire du code PostScript.
Pour la conversion en PDF, on aura le choix entre pdflatex à utiliser directement sur le code source
et ps2pdf qu'on utilisera à partir du document créé avec dvips.

Netographie

– http://www.grappa.univ-lille3.fr/FA...
– http://tex.loria.fr
– http://melusine.eu.org/syracuse/
– http://www.math.jussieu.fr/~zoonek/...
– http://www.lyx.org
– http://www.tug.org/teTeX

Bien sûr LaTeX offre de multiples arrangements graphiques comme par exemple la gestion complÚte de la dimension de la page.

On pourra aussi explorer dans un autre article, l'insertion d'images ou encore la production de figures géométriques.