summaryrefslogtreecommitdiffhomepage
path: root/fr-fr
diff options
context:
space:
mode:
Diffstat (limited to 'fr-fr')
-rw-r--r--fr-fr/make-fr.html.markdown268
-rw-r--r--fr-fr/wolfram-fr.html.markdown167
2 files changed, 435 insertions, 0 deletions
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
new file mode 100644
index 00000000..5a1e03e7
--- /dev/null
+++ b/fr-fr/make-fr.html.markdown
@@ -0,0 +1,268 @@
+---
+language: make
+contributors:
+ - ["Robert Steed", "https://github.com/robochat"]
+translators:
+ - ["altaris", "https://github.com/altaris"]
+filename: Makefile-fr
+lang: fr-fr
+---
+
+Un makefile est un fichier qui définit un ensemble de règles liées entre elles
+pour créer une ou plusieurs cibles. L'idée est d'effectuer le moins de travail
+possible afin de mettre à jour la ou les cibles en fonction des dépendances.
+
+Écrit en un week-end par Stuart Feldman en 1976, le make et les
+makefiles sont encore très utilisés (principalement dans les systèmes Unix),
+malgré la concurrence et les critiques faites à son égard.
+
+Le programme make a plusieurs variantes. Dans ce tutoriel, nous utiliserons
+l'implémentation standard : GNU make.
+
+```make
+
+# Ceci est un commentaire.
+
+# Un makefile devrait être nommé "Makefile" (avec ou sans la
+# majuscule). Il peut alors être exécuté par `make <cible>`.
+# Ce nommage n'est toutefois pas obligatoire : utiliser
+# `make -f "fichier" <cible>`.
+
+# ATTENTION : l'indentation est quant à elle obligatoire, et se fait avec des
+# tabulations, pas avec des espaces !
+
+#-----------------------------------------------------------------------
+# Les basiques
+#-----------------------------------------------------------------------
+
+# Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
+fichier0.txt:
+ echo "truc" > fichier0.txt
+ # Même les commentaires sont transférés dans le terminal.
+
+# Cette règle ne sera exécutée que si fichier0.txt est plus récent que
+# fichier1.txt.
+fichier1.txt: fichier0.txt
+ cat fichier0.txt > fichier1.txt
+ # Utiliser la même syntaxe que dans un terminal.
+ @cat fichier0.txt >> fichier1.txt
+ # @ empêche l'affichage de la sortie texte d'une commande.
+ -@echo 'hello'
+ # - signifie que la règle devrait continuer à s'exécuter si cette commande
+ # échoue.
+
+# Une règle peut avoir plusieurs cibles et plusieurs dépendances.
+fichier2.txt fichier3.txt: fichier0.txt fichier1.txt
+ touch fichier2.txt
+ touch fichier3.txt
+
+# Make affichera un avertissement si le makefile comporte plusieurs règles pour
+# une même cible. Cependant les règles vides ne comptent pas, et peuvent être
+# utilisées pour ajouter des dépendances plus facilement.
+
+#-----------------------------------------------------------------------
+# Fausses règles
+#-----------------------------------------------------------------------
+
+# Une fausse règle est une règle qui ne correspond pas à un fichier.
+# Par définition, elle ne peut pas être à jour, et donc make l’exécutera à
+# chaque demande.
+all: maker process
+
+# La déclaration des règles peut être faite dans n'importe quel ordre.
+maker:
+ touch ex0.txt ex1.txt
+
+# On peut transformer une règle en fausse règle grâce à la cible spéciale
+# suivante :
+.PHONY: all maker process
+
+# Une règle dépendante d'une fausse règle sera toujours exécutée.
+ex0.txt ex1.txt: maker
+
+# Voici quelques exemples fréquents de fausses règles : all, make, clean,
+# install...
+
+#-----------------------------------------------------------------------
+# Variables automatiques et wildcards
+#-----------------------------------------------------------------------
+
+# Utilise un wildcard pour des noms de fichier
+process: fichier*.txt
+ @echo $^ # $^ est une variable contenant la liste des dépendances de la
+ # cible actuelle.
+ @echo $@ # $@ est le nom de la cible actuelle. En cas de cibles
+ # multiples, $@ est le nom de la cible ayant causé l'exécution
+ # de cette règle.
+ @echo $< # $< contient la première dépendance.
+ @echo $? # $? contient la liste des dépendances qui ne sont pas à jour.
+ @echo $+ # $+ contient la liste des dépendances avec d'éventuels
+ # duplicatas, contrairement à $^.
+ @echo $| # $| contient la liste des cibles ayant préséance sur la cible
+ # actuelle.
+
+# Même si la définition de la règle est scindée en plusieurs morceaux, $^
+# listera toutes les dépendances indiquées.
+process: ex1.txt fichier0.txt
+# Ici, fichier0.txt est un duplicata dans $+.
+
+#-----------------------------------------------------------------------
+# Pattern matching
+#-----------------------------------------------------------------------
+
+# En utilisant le pattern matching, on peut par exemple créer des règles pour
+# convertir les fichiers d'un certain format dans un autre.
+%.png: %.svg
+ inkscape --export-png $^
+
+# Make exécute une règle même si le fichier correspondant est situé dans un sous
+# dossier. En cas de conflit, la règle avec la meilleure correspondance est
+# choisie.
+small/%.png: %.svg
+ inkscape --export-png --export-dpi 30 $^
+
+# Dans ce type de conflit (même cible, même dépendances), make exécutera la
+# dernière règle déclarée...
+%.png: %.svg
+ @echo cette règle est choisie
+
+# Dans ce type de conflit (même cible mais pas les mêmes dépendances), make
+# exécutera la première règle pouvant être exécutée.
+%.png: %.ps
+ @echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
+
+# Make a des règles pré établies. Par exemple, il sait comment créer la cible
+# *.o à partir de *.c.
+
+# Les makefiles plus vieux utilisent un matching par extension de fichier.
+.png.ps:
+ @echo cette règle est similaire à une règle par pattern matching
+
+# Utiliser cette règle spéciale pour déclarer une règle comme ayant un
+# matching par extension de fichier.
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variables, ou macros
+#-----------------------------------------------------------------------
+
+# Les variables sont des chaînes de caractères.
+
+variable = Ted
+variable2="Sarah"
+
+echo:
+ @echo $(variable)
+ @echo ${variable2}
+ @echo $variable # Cette syntaxe signifie $(n)ame et non pas $(variable) !
+ @echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
+
+# Les variables sont déclarées de 4 manières, de la plus grande priorité à la
+# plus faible :
+# 1 : dans la ligne de commande qui invoque make,
+# 2 : dans le makefile,
+# 3 : dans les variables d’environnement du terminal qui invoque make,
+# 4 : les variables prédéfinies.
+
+# Assigne la variable si une variable d’environnement du même nom n'existe pas
+# déjà.
+variable4 ?= Jean
+
+# Empêche cette variable d'être modifiée par la ligne de commande.
+override variable5 = David
+
+# Concatène à une variable (avec un espace avant).
+variable4 +=gris
+
+# Assignations de variable pour les règles correspondant à un pattern
+# (spécifique à GNU make).
+*.png: variable2 = Sara # Pour toutes les règles correspondant à *.png, et tous
+ # leurs descendants, la variable variable2 vaudra
+ # "Sara".
+# Si le jeux des dépendances et descendances devient vraiment trop compliqué,
+# des incohérences peuvent survenir.
+
+# Certaines variables sont prédéfinies par make :
+affiche_predefinies:
+ echo $(CC)
+ echo ${CXX}
+ echo $(FC)
+ echo ${CFLAGS}
+ echo $(CPPFLAGS)
+ echo ${CXXFLAGS}
+ echo $(LDFLAGS)
+ echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variables : le retour
+#-----------------------------------------------------------------------
+
+# Les variables sont évaluées à chaque instance, ce qui peut être coûteux en
+# calculs. Pour parer à ce problème, il existe dans GNU make une seconde
+# manière d'assigner des variables pour qu'elles ne soient évaluées qu'une seule
+# fois seulement.
+
+var := A B C
+var2 ::= $(var) D E F # := et ::= sont équivalents.
+
+# Ces variables sont évaluées procéduralement (i.e. dans leur ordre
+# d'apparition), contrairement aux règles par exemple !
+
+# Ceci ne fonctionne pas.
+var3 ::= $(var4) et fais de beaux rêves
+var4 ::= bonne nuit
+
+#-----------------------------------------------------------------------
+# Fonctions
+#-----------------------------------------------------------------------
+
+# Make a une multitude de fonctions. La syntaxe générale est
+# $(fonction arg0,arg1,arg2...).
+
+# Quelques exemples :
+
+fichiers_source = $(wildcard *.c */*.c)
+fichiers_objet = $(patsubst %.c,%.o,$(fichiers_source))
+
+ls: * src/*
+ @echo $(filter %.txt, $^)
+ @echo $(notdir $^)
+ @echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directives
+#-----------------------------------------------------------------------
+
+# Inclut d'autres makefiles.
+include meuh.mk
+
+# Branchements conditionnels.
+sport = tennis
+report:
+ifeq ($(sport),tennis) # Il y a aussi ifneq.
+ @echo 'jeu, set et match'
+else
+ @echo "C'est pas ici Wimbledon ?"
+endif
+
+truc = true
+ifdef $(truc) # Il y a aussi ifndef.
+ machin = 'salut'
+endif
+```
+
+## Quelques références
+
+### En français
+
++ [Introduction à Makefile (developpez.com)]
+(http://gl.developpez.com/tutoriel/outil/makefile/),
++ [Compilez sous GNU/Linux ! (openclassrooms)]
+(https://openclassrooms.com/courses/compilez-sous-gnu-linux).
+
+### En anglais
+
++ [Documentation de GNU make](https://www.gnu.org/software/make/manual/),
++ [Software carpentry tutorial](http://swcarpentry.github.io/make-novice/),
++ Learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html)
+[ex28](http://c.learncodethehardway.org/book/ex28.html).
diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
new file mode 100644
index 00000000..7b446259
--- /dev/null
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -0,0 +1,167 @@
+---
+language: wolfram
+contributors:
+ - ["hyphz", "http://github.com/hyphz/"]
+translators:
+ - ["altaris", "http://github.com/altaris/"]
+filename: learnwolfram-fr.nb
+lang: fr-fr
+---
+
+Le langage Wolfram est utilisé dans les programmes suivants :
+* La ligne de commandes interactive noyau du Raspberry Pi, mais elle ne peut pas
+gérer des éléments graphiques.
+* _Mathematica_, un éditeur de texte riche spécialisé pour les mathématiques :
+appuyer sur `Shift + Entrée` dans une cellule de code crée un nouvelle cellule
+contenant le résultat.
+* _Wolfram Wokbench_, une variante d'Eclipse spécialisée pour le langage
+Wolfram.
+
+Ce code d'exemple peut être utilisé et modifié dans ces logiciels. Cependant, le
+copier-coller directement dans Mathematica peut causer des problèmes de
+formatage, car il ne contient aucune information de mise en page.
+
+```
+(* Ceci est un commentaire *)
+
+(* Dans Mathematica, au lieu d'utiliser ces commentaires, vous pouvez créer des
+ cellules de texte et insérer de jolies images *)
+
+(* Saisissez une opération et appuyez sur Shift + Entrée pour obtenir le
+ résultat *)
+2*2 (* 4 *)
+5+8 (* 13 *)
+
+(* Appels de fonction *)
+Sin[Pi/2] (* 1 *)
+(* Syntaxe alternative pour les appels de fonction à 1 paramètre *)
+Sin@(Pi/2) (* 1 *)
+(Pi/2) // Sin (* 1 *)
+
+(* Attention : le langage est sensible à la casse ! *)
+
+(* Toutes les expressions sont en réalité des appels de fonction *)
+Times[2, 2] (* 4 *)
+Plus[5, 8] (* 13 *)
+
+(* Utiliser une variable pour la première fois la déclare globalement *)
+x = 5 (* 5 *)
+x == 5 (* True, l'assignation et le test d'égalité est écrit comme
+ en C *)
+x (* 5 *)
+x = x + 5 (* 10 *)
+x (* 10 *)
+Set[x, 20] (* TOUT est un appel de fonction, TOUUUUUUUUT *)
+x (* 20 *)
+
+(* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
+ variables non déclarées est légal *)
+truc + 5 (* 5 + truc, comme truc n'est pas déclarée, l'évaluation
+ s'arrête là *)
+truc + 5 + 10 (* 15 + truc, on évalue ce qu'on peut... *)
+% (* 15 + truc, % représente le dernier résultat *)
+% - truc (* 15, les variables non déclarées peuvent quand même
+ s'annuler *)
+chose = truc + 5 (* Attention : chose est ici une expression et non un nombre *)
+
+(* Déclaration d'une fonction *)
+Double[x_] := x * 2 (* Le symbole := empêche l'évaluation immédiate du terme
+ à droite *)
+Double[10] (* 20 *)
+Double[Sin[Pi/2]] (* 2 *)
+Double @ Sin @ (Pi/2) (* 2, Utiliser @ évite les paquets de crochets
+ fermants si moches *)
+(Pi/2) // Sin // Double (* 2, Utiliser // permet d'écrire les fonctions dans
+ l'ordre d'appel *)
+
+(* En programmation impérative, utiliser ; pour séparer les expressions *)
+Salut[] := (Print@"Hello"; Print@"World") (* Les parenthèses sont nécessaires
+ car ; est prioritaire sur := *)
+Salut[] (* Hello World *)
+
+(* Boucles For à la C *)
+Compter[x_] := For[y=0, y<x, y++, (Print[y])] (* L'évaluation des boucles For
+ se fait comme en C *)
+Compter[5] (* 0 1 2 3 4 *)
+
+(* Boucles While *)
+x = 0; While[x < 2, (Print@x; x++)] (* De nouveau, comme en C *)
+
+(* Expressions conditionnelles et If *)
+x = 8; If[x==8, Print@"Huit", Print@"Pas huit"] (* If [condition, si vrai,
+ si faux] *)
+Switch[x, 2, Print@"Deux", 8, Print@"Huit"] (* Switch par valeur *)
+Which[x==2, Print@"Deux", x==8, Print@"Huit"] (* Switch du type if, else if,
+ else if, ..., else *)
+
+(* Les variables autres que les paramètres de fonctions sont par défaut
+ globales, même à l'intérieur des fonctions *)
+y = 10 (* 10, y est une variable globale *)
+Compter[5] (* 0 1 2 3 4 *)
+y (* 5, y a été modifiée par Compter *)
+x = 20 (* 20, x est une variable globale *)
+Compter[5] (* 0 1 2 3 4 *)
+x (* 20, dans Compter, le paramètre x masque la variable
+ globale x *)
+
+(* La fonction Module permet d'utiliser des variables locales *)
+MieuxCompter[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+y = 20 (* y est une variable globale *)
+MieuxCompter[5] (* 0 1 2 3 4 *)
+y (* 20, y n'a pas été modifiée car le y du Module masque le
+ y global. C'est bien mieux comme ça ! *)
+
+(* Module permet de faire des déclarations globales aussi *)
+Module[{compte}, compte=0; (* compte est une variable locale *)
+ (Incrementer[] := ++compte); (* Ce module déclare des fonctions, mais elles
+ ne sont globales. Elles ont cependant accès
+ aux variables locales au module. *)
+ (Decrementer[] := --compte)]
+compte (* compte, car il n'y a pas de variable globale nommée
+ compte *)
+Incrementer[] (* 1, la fonction utilise la variable compte du module *)
+Incrementer[] (* 2, le précédent appel de Incrementer a modifié compte *)
+Decrementer[] (* 1 *)
+compte (* compte, car il n'existe toujours pas de variable globale
+ nommé compte *)
+
+(* Listes *)
+liste = {1, 2, 3, 4} (* {1, 2, 3, 4} *)
+liste[[1]] (* 1, les indexes commencent à 1 et non 0 !!! *)
+Map[Double, liste] (* {2, 4, 6, 8}, appliquer une fonction à une liste de
+ manière fonctionnelle *)
+Double /@ liste (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
+ précédente *)
+Scan[Print, liste] (* 1 2 3 4, boucle impérative sur une liste *)
+Fold[Plus, 0, liste] (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, liste] (* {0, 1, 3, 6, 10}, variante de la fonction
+ précédente qui donne aussi les résultats
+ intermédiaires *)
+Append[liste, 5] (* {1, 2, 3, 4, 5}, liste n'est pas modifiée... *)
+Prepend[liste, 5] (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en
+ écrivant "liste = " *)
+Join[liste, {3, 4}] (* {1, 2, 3, 4, 3, 4} *)
+liste[[2]] = 5 (* {1, 5, 3, 4}, ceci modifie bien la liste *)
+
+(* Tables associatives, ou dictionnaires *)
+table = <|"Vert" -> 2, "Rouge" -> 1|> (* Crée une table associative *)
+table[["Vert"]] (* 2, l'utilise *)
+table[["Vert"]] := 5 (* 5, la modifie *)
+table[["Bleu"]] := 3.5 (* 3.5, l'étend *)
+KeyDropFrom[table, "Vert"] (* Supprime la clé "Vert" *)
+Keys[table] (* {Rouge, Bleu} *)
+Values[table] (* {1, 3.5} *)
+
+(* Pour finir, toute bonne démonstration du langage Wolfram contient un
+ Manipulate ! *)
+Manipulate[y^2, {y, 0, 20}] (* Crée une interface graphique interactive qui
+ affiche y^2, permettant à l'utilisateur de
+ modifier la valeur de y grâce à un contrôle
+ allant de 0 à 20. Ne fonctionne que si le
+ logiciel utilisé gère les éléments graphiques. *)
+```
+
+## Envie d'aller plus loin ?
+
+* [Documentation du langage Wolfram (en anglais)]
+(http://reference.wolfram.com/language/)