Langages de programmation

• 1: Bash
• 2: Makefile
• 3: Python
• 4: C/C++
• 5: Fortran
• 6: Julia
• 7: R
• 8: latex
• 9: Markdown

1 - Bash

L’utilisation de scripts bash (ou son alternative, zsh) est un moyen pratique d’automatiser une foule de tâches dans un environnement *nix (linux, macOS, etc.) – du lancement automatique de codes de calcul à l’exécution de tâches de maintenance.

Creation d’un script

Création d’un script minimal et syntaxe de base.

Un script bash est simplement un fichier texte exécutable qui comporte optionnellement une extension .sh. Pour créer le script test.sh et le rendre exécutable, on peut faire:

touch test.sh
chmod 700 test.sh

On doit ensuite inscrire la ligne suivante au début du fichier:

#/usr/bin/env bash

Usage de base

Chaque ligne d’un script bash est ensuite simplement exécutée comme si elle était entrée manuellement à l’invite de commande.

On peut également se servir de tests conditionnels pour diriger l’exécution de script,

if [[ -z "$string" ]]; then
  echo "String is empty"
elif [[ -n "$string" ]]; then
  echo "String is not empty"
fi

de variables,

NAME="John"
echo $NAME
echo "$NAME"
echo "${NAME}!"

Il possible d’effectuer certaines opérations mathématiques de base en bash, qui pourraient être utiles pour nommer des fichiers de façon séquentielle, par exemple, mais la syntaxe n’est pas très sexy:

NCYC=2
NREP=8
NT=$((100*NCYC*NREP))
SIMNAME='simcool_'$NT

etc.

2 - Makefile

Un script Makefile est à bien des égards similaire à un script Bash, mais possède une syntaxe parfois légèrement différente. Les scripts Makefile sont exécutés non pas par bash mais par make, et servent de manière générale à compiler des objets.

Exemple: compilation d’un document LaTeX

On peut se servir d’un Makefile pour compiler automatiquement et rapidement un document latex.

Par exemple, on peut se servir d’un script de ce genre pour compiler un document latex:

.IGNORE:

default:
    pdflatex <document-name>
    chflags -R hidden *.aux *.bbl *.blg *.log *.out *.lof *.lot *.toc 
bib:
    pdflatex <document-name>
    bibtex <document-name>
    pdflatex <document-name>
    pdflatex <document-name>
    chflags -R hidden *.aux *.bbl *.blg *.log *.out *.lof *.lot *.toc 

clean:
    rm -r *.aux *.bbl *.blg *.log *.out *.lof *.lot *.toc

En copiant le texte ci-dessus dans un fichier sans extension nommé Makefile (notez le M majuscule), on peut alors taper les commandes suivantes dans le répertoire où se trouve le fichier pour exécuter les commandes associées du Makefile:

• make : exécute la section default (compile le fichier latex)
• make bib : exécute la section bib (compile le fichier latex et la bibliographie)
• make clean : exécute la section clean (nettoie le répertoire des fichiers temporaires)

Exemple: compilation d’un code C

Un exemple un peu plus élaboré: conception d’un Makefile pour compiler un code C à l’aide de gcc.

On peut aussi se servir d’un Makefile pour compiler un code C. Par exemple, le script suivant compile mon code de calcul selon le système d’exploitation (la procédure de compilation diffère de l’un à l’autre):

CXX		:= g++
RM		:= rm -f
CPPFLAGS	:=
LDFLAGS		:= -O2 -fmax-errors=5 -fcompare-debug-second
LDLIBS-MACOS	:= -I/usr/local/include -L/usr/local/lib -lgsl
LDLIBS-CENTOS	:= -I/home/alexandre/lib/gsl/include -L/home/alexandre/lib/gsl/lib -lgsl -lgslcblas

SRC_DIR		:= src
SRCS		:= $(wildcard $(SRC_DIR)/*.cpp)
BUILD		:=build/clipd
LATEST_VERSION	:=3

all:
	@echo MacOS or CentOS?
	@exit 1
version_check:
ifdef v
else
	$(eval v=$(LATEST_VERSION))
	@echo No version specified, making version $(v)
endif
macos: version_check
	@echo Building for MacOS...; echo ""
	$(CXX) $(LDFLAGS) $(LDLIBS-MACOS) $(SRC_DIR)$(v)/*.cpp -o $(BUILD)$(v)

centos: version_check
	@echo Building for CentOS...; echo ""
	$(CXX) $(LDFLAGS) $(LDLIBS-CENTOS) $(SRC_DIR)$(v)/*.cpp -o $(BUILD)$(v)

clean:
	$(RM) $(BUILD)*

On peut alors se servir soit de make macos ou de make centos afin de compiler le code.

3 - Python

Vous êtes probablement déjà relativement familier avec Python, donc je ne m’étendrai pas sur le détail de la syntaxe. Toutefois, quelques informations pertinentes peuvent être mentionnées ici.

Environnements

Présentation des divers environnements (interpréteurs, gestionnaires de packages et outils) supportant Python.

Anaconda

Anaconda est probablement la distribution la plus populaire du langage Python, disponible sur plusieurs plateformes.

On peut y créer des environnements virtuels qui comportent une configuration précise (packages présents, etc.) en faisant:

conda create -n my-env
conda activate my-env

Pour installer un module:

conda install <module>

Pour ajouter un répertoire au PYTHONPATH, ce qui permet de créer soi-même des modules:

conda develop <dir>

Packages utiles

Quelques packages utiles pour la modélisation numérique.

• numpy : se passe de présentation.
• matplotlib : idem.
• scipy : idem.
• click : permet de créer facilement des interfaces de ligne de commande.
• pickle : lecture/écriture disque d’objets en mode binaire.
• tqdm : création de barres d’avancement en ligne de commande.
• numba : permet de précompiler du code Python, ce qui accélère énormément sa vitesse d’exécution¹.

Interface avec d’autres langages

Packages permettant de créer des codes hybrides comportant des modules compilés en C ou en Fortran, d’exécution beaucoup plus rapide que le Python de manière générale.

On peut interfacer du code Python avec des routines écrites en C ou en Fortran, avec Cython et F2PY respectivement.

4 - C/C++

Un des attraits importants des langages compilés (tels C et C++) par rapport aux langages interprétés (tel Python) vient de leur vitesse d’exécution.

Voici un bref comparatif:

Le principal désavantage de ce type de langage est toutefois l’offre beaucoup moins importante de librairies scientifiques (pas de numpy ici) et la syntaxe parfois plus complexe que celle des langages plus “haut niveau”.

Le langage C possède par ailleurs plusieurs versions (C11, C17) et une extension orientée-objet – le C++.

Finalement, on peut interfacer du code C et du code Python via Cython.

Exemple introductif

Syntaxe et compilation d’un exemple minimal de type “hello world”.

Un code C de type “hello world” pourrait ressembler à:

#include <stdio.h>
int main() {
   // printf() displays the string inside quotation
   printf("Hello, World!");
   return 0;
}

En plaçant ce code dans le fichier hello.c, on peut compiler avec

gcc hello.c -o hello

ce qui produit l’exécutable hello.

Librairies scientifiques

Recersion des librairies de calcul scientifique en C/C++.

GNU Scientific Library (GSL)

La GSL est l’une des principales libraires de calcul scientifique en C. Bref aperçu des fonctionnalités:

• Complex Numbers
• Roots of Polynomials
• Special Functions
• Vectors and Matrices
• Permutations
• Sorting
• BLAS Support
• Linear Algebra
• Eigensystems
• Fast Fourier Transforms
• Quadrature
• Random Numbers
• Quasi-Random Sequences
• Random Distributions
• Statistics
• Histograms
• N-Tuples
• Monte Carlo Integration
• Simulated Annealing
• Differential Equations
• Interpolation
• Numerical Differentiation
• Chebyshev Approximation
• Series Acceleration
• Discrete Hankel Transforms
• Root-Finding
• Minimization
• Least-Squares Fitting
• Physical Constants
• IEEE Floating-Point
• Discrete Wavelet Transforms
• Basis splines
• Running Statistics
• Sparse Matrices and Linear Algebra

5 - Fortran

Le principal attrait du Fortran est qu’il est, comme le C, un langage compilé. Ceci signifie que sa vitesse d’exécution est bien supérieure à votre Python habituel.

La syntaxe générale de Fortran est relativement simple, et il est encore beaucoup utilisé dans plusieurs groupe de recherche vu sa popularité dans les années 80-90.

On peut notamment utiliser F2PY pour interfacer du code Python avec du code Fortran – donc “inclure” des routines Fortran dans un code d’analyse Python plus large, par exemple.

Exemple introductif

Syntaxe et compilation d’un exemple minimal de type “hello world”.

Un code Fortran de type “hello world” pourrait ressembler à:

program hello
  ! This is a comment line; it is ignored by the compiler
  print *, 'Hello, World!'
end program hello

On peut le compiler à l’aide de

gfortran -o hello hello.f90

ce qui produit l’exécutable hello.

6 - Julia

Julia est un langage de haut niveau récent qui peut approcher la vitesse d’exécution de certains codes compilés traditionnels (C, Fortran). Il est couramment utilisé dans les groupes de recherche de biologie.

7 - R

8 - latex

J’imagine que rendu ici vous êtes tout à fait familiers avec le langage latex, donc je ne vais y consigner que des éléments plus avancés.

Gestion bibliographique

Quelques formats/packages de gestion bibliographique pour latex.

bibtex

Bibtex est l’un des plus vieux format de gestion bibliographique sous latex. On l’utilise avec le package natbib. Plusieurs journaux nécessitent l’entrée de citations avec natbib.

biblatex

Plus récent que bibtex, le format BibLatex (et le package du même nom) possèdent de nombreuses fonctionnalités avancées que bibtex ne fournit pas, par exemple imprimer (facilement…) des entrées bibliographiques dans le texte, etc.

Éditeurs

Quelques éditeurs, tant spécifiques au latex que généraux.

texpad

Texpad est un éditeur macOS relativement bien conçu qui a deux avantages plutôt pratiques selon moi:

• complétion automatique (ou suggestions) lorsqu’on cite, car il lit les fichiers de bibliographie
• prévisualisation en temps réel du document – ce qui en fait un outil bien pratique pour rédiger rapidement de petits documents (e.g. lettres, etc.)¹

Overleaf

Overleaf est un service en ligne qui permet de créer des documents latex et de les visualiser directement dans le fureteur. Se connecte optionnellement avec d’autres services (e.g. Github) ce qui peut être pratique. Possède également des fonctionnalités de collaboration entre auteurs.

emacs

emacs peut évidemment servir à éditer des documents latex, et possède par ailleurs certaines extensions destinées précisément à ça (auctex, par exemple).

9 - Markdown

Le langage Markdown est une sorte de version très très simplifiée de latex, qui permet de créer des documents simples comportant certains éléments de mise en forme. Le site web que vous lisez présentement utilise une variation du langage Markdown.

Il est très utile pour prendre des notes de manière plus informelle qu’avec latex, mais peut également être utilisé pour produire des documents PDF. On peut aussi y entrer des équations, ajouter des images, etc.

Éditeurs

Quelques éditeurs pouvant être utilisés pour le Markdown.

MacDown

MacDown est un éditeur open source sous macOS qui permet de créer rapidement des documents Markdown et de les prévisualiser.

emacs

Comme pour l’édition de documents latex, emacs est un autre éditeur très pratique pour l’édition de documents Markdown – à ceci près qu’il ne possède pas de fonction de prévisualisation comme e.g. MacDown.

Obsidian

Obsidian est basé sur une certaine variation du langage Markdown, et peut être tout à fait utile pour entrer des notes dans ce langage. Moins pratique pour l’édition de fichiers individuels toutefois.

Syntaxe de base

Syntaxe de base commune à virtuellement toutes les implémentations de Markdown.

On insère les titres en sous-titres via

# Titre
## Sous-titre
### Sous-sous-titre

Le texte peut être formatté selon:

Blocs de code

On peut insérer des blocs de code via

```bonjour```

ce qui donne

bonjour

Citations

On peut également insérer des citations via

> bonjour

ce qui donne

bonjour

Images

On insère des images en utilisant du code HTML, qui est plus pratique que le code Markdown pour inclure les images (et ne permet pas de les redimensionner):

<img src="cutecat.jpg" style="width:20%">

Résultat: