Document computationnel avec R

Pour le partage et la reproductibilité de ses analyses

Séance ElementR - Octobre 2023

Hugues Pecout (CNRS, UMR Géographie-Cités)

Adapter ses méthodes de travail traditionnelles

L’utilisation d’un langage de programmation promet des perspectives intéressantes :

  1. Permet la mise en place de chaîne de traitement complète et singulière
  2. Offre plus de transparence pour ses analyses
  3. Facilite le partage de son travail
  4. Permet la réproductibilité de ses analyses

Mais cela implique de nouvelles méthodes de travail

  • Comment rendre mes scripts intelligibles pour mes collègues (et pour moi !) ?
  • Comment assurer une certaine reproductibilité de mes scripts ?
  • Comment mettre à disposition et archiver du code source et ses résultats ?

Solutions ?


  1. Pratique de la programmation lettrée


  1. Utilisation de documents computationnels


  1. Gestion et partage du code avec une forge logicielle

Literate programming


La programmation lettrée est une approche de la programmation qui se veut différente du paradigme de programmation structurée.

« Nous devons changer notre attitude traditionnelle envers la construction des programmes : au lieu de considérer que notre tâche principale est de dire à un ordinateur ce qu’il doit faire, appliquons-nous plutôt à expliquer à des êtres humains ce que nous voulons que l’ordinateur fasse. (…)

Celui qui pratique la programmation lettrée peut être vu comme un essayiste, qui s’attache principalement à exposer son sujet dans un style visant à l’excellence. Tel un auteur, il choisit, avec soin, le dictionnaire à la main, les noms de ses variables et en explique la signification pour chacune d’elles. Il cherche donc à obtenir un programme compréhensible parce que ses concepts sont présentés dans le meilleur ordre possible. Pour cela, il utilise un mélange de méthodes formelles et informelles qui se complètent. »

D. Knuth, « Literate Programming », The Computer Journal, British Computer Society, vol. 27, no 2,‎ 1984, p. 97–111

Le paradigme de la programmation lettrée, pensé et mis en oeuvre par Donald Knuth (1977-78), s’éloigne dans son écriture de l’ordonnancement imposé par l’ordinateur, et à la place autorise les développeurs à utiliser un ordre imposé par la logique et le fil de leur pensée.

Quelques lignes de code…

library(ggplot2)
ggplot(data = iris, 
       aes(x = cut(Sepal.Length, breaks = c(min(Sepal.Length), 5, 6, 7, max(Sepal.Length)), 
                   include.lowest = TRUE, labels = c("Bas","Bas+","Haut","Haut+")))) +
  geom_bar() + xlab("") + ylab("") + ggtitle("Répartition par classe") +
  theme(plot.title = element_text(size=27), axis.text=element_text(size=19))

…En programmation lettrée

#-----------------------------------------------------------------
#            Représentation graphique 
#         de la répartition d'individus
#         discrétisés en quatre classes 
#
#                  H. Pecout
#               3 Octobre 2023
#-----------------------------------------------------------------

# Discrétisation la variable Sepal.Length (données iris)

## Statistiques sur la série statistique 'Sepal.Length'
summary(iris$Sepal.Length)

## Histogramme de la distribution
hist(iris$Sepal.Length)

## Choix des bornes de classes (amplitude égale)
bornes_des_classes <- c(min(iris$Sepal.Length), 5, 6, 7, 
                        max(iris$Sepal.Length))

## Choix des noms de classes
nom_des_classes <- c("Trés petites","petites","grandes","Très grandes")

## Discrétisation de la variable 'Sepal.length'
iris$classe  <- cut(iris$Sepal.Length,
                    breaks = bornes_des_classes,
                    labels = nom_des_classes,
                    include.lowest = TRUE)

#---------------------------------------------------------------------

# Représentation de la distribution selon la discrétisation

## Bibliothèque pour la représentation graphique
library(ggplot2)

## Représentation graphique de la distribution
ggplot(data = iris, aes(x = classe)) +  # Choix des données et de la variable à représenter
  geom_bar() +  # Choix du type de représentation
  xlab("") +    # Suppression du nom de l'axe x
  ylab("") +    # Suppression du nom de l'axe y
  ggtitle("Répartition par classe") +  # Titre du graphique
  theme(plot.title = element_text(size=27),  # Taille de la police titre 
        axis.text=element_text(size=19))     # Taille des labels d'axe

LP et document computationnel

Il est possible de faire de la programmation lettrée dans n’importe quel type de document…
Mais le document computionnel est l’environnement parfait pour mettre en oeuvre ce paradigme.

Un document computationnel permet de combiner du langage naturel et du langage de programmation :

  • Le texte peut être mis en forme
  • Le code peut être affiché, éxécuté et les résultats affichés


La programmation lettrée et les documents computionnels sont apparus à la même période, celle de l’émergence du concept de recherche reproductible !

💻 70’s show

Les premiers notebooks

  • 1970 : Scratchpad (Axiom)
  • 1987 : MathCad
  • 1988 : Mathematica
  • 1989 : Maple
  • 2011 : IPython

Émergence de la recherche reproductible

Jon Claerbout est l’un des premiers chercheur à exprimer le fait que les méthodes de calcul menacent la reproductibilité de la recherche si l’on ne donne pas un accès libre aux données et aux logiciels qui sous-tendent.

En 1976, il publie un ouvrage référence en traitement de signal :
« Fundamentals of Geophysical Data Processing »

Cette 1ère version - non-reproductible - sera le début d’un long travail de recherche sur la reproductibilité… Via des notebooks !


Émergence du Literate Programming

Le concept de programmation lettrée est pensé et conçu par Donald Knuth (1977-78). Le notebook se présente comme un outil idéal pour mettre en œuvre ce paradigme.

Document computationnel ?

Définition : interface de programmation qui permet de combiner des sections en langage naturel et des sections en langage informatique.

En raison de l’évolution et de la diversité des outils logiciels disponibles dans ce domaine, il existe de nombreuses dénominations pour les documents computationnels .

Cela reflète la diversité de leurs caractèristiques, de leurs fonctionnalités et des approches différentes de conception.

C’est la raison pour laquelle, les noms propres des différents dispositifs son souvent utilisés (ex : carnet Jupyter, Observable, Rmarkdown, Quarto…)

  • Article exécutable
  • Bloc-code (Arthur Perret, 2021)
  • Document computationnel
  • Document électronique interactif
  • Cahiers de programmation
  • Cahier électronique d’analyse
  • Calepin électronique
  • Carnet de code
  • Manifeste algorithmique
  • Notebook

Un outil, plusieurs pratiques

La mise en forme du texte se fait à l’aide d’un langage de balisage (Markdown, html…)

Les notebooks en SHS

Et depuis 2022… !

Un outil de publication complet

Nombreuses fonctionnalités :

  • Équivalent à LaTeX (+ langage de programmation)
  • Bibliographie, note bas de page, TOC, TOF…
  • Feuille de style CSS & nombreux templates
  • Interactivité (html, javascript)
  • Et bien plus avec Quarto !

 

Format de publication légitime

Différents type de publication

Anatomie d’un notebook

Un fichier texte (.rmd, .qmd, .ipynb…)

I. L’en-tête (YAML)


Le YAML en début de document est délimité par 3 tirets : “---”.
Il contient des variables paramétrables qui seront prises en compte à la compilation du document.

---
title: Programmation lettrée et Notebook
date: 03/10/2023
---


Ces variables sont des métadonnées comme le titre, auteur·es, date… Mais aussi des indications sur le format de sortie et la mise en page (template, TOC, numérotation, CSS, Biblio…).


L’indentation doit être parfaitement respectée


YAML Rmarkdown
---
title: Programmation lettrée et Notebook
subtitle: Mise en pratique avec Rmarkdown et Quarto
author: Hugues Pecout
date: 2023-10-03

css: style.css
bibliography: references.bib
csl: apa.csl
nocite: '@*'

output:
  rmdformats::readthedown:
    self_contained: true
    highlight: tango
---
      
YAML Quarto
---
title: Programmation lettrée et Notebook
subtitle: Mise en pratique avec Rmarkdown et Quarto
author: Hugues Pecout
institute: "Géographie-Cités, CNRS"
lang: fr
format:
  revealjs: 
    template-partials:
      - title-slide.html
    theme: [dark, styles.scss]
    logo: img/ElementR.png
    footer: "Séance ElementR - Document computationnel"
    scrollable: TRUE
    overview: TRUE
    transition: fade
    menu: TRUE
    css: style.css
---

II. Corps du document


Deux types de contenus peuvent s’entremêler dans le corps d’un notebook :

 

A. Texte balisé en markdown pour la mise en forme.


B. Bloc de code (ou chunk en R) contenant un langage de programmation.



À la compilation du document :

Le code est exécuté (ou non) et ses résultats, ainsi que le texte balisé en markdown sont mis en forme pour généré un document en pdf, html, word…

A. Écrire en Markdown → https://hackmd.io/

B. Langage de programmation (ex R)

Bloc code - chunk

Délimité par 3 backquotes. Langage indiqué entre {}.

```{r}

head(mtcars[, 1:5])

```

head(mtcars[, 1:4])
                   mpg cyl disp  hp
Mazda RX4         21.0   6  160 110
Mazda RX4 Wag     21.0   6  160 110
Datsun 710        22.8   4  108  93
Hornet 4 Drive    21.4   6  258 110
Hornet Sportabout 18.7   8  360 175
Valiant           18.1   6  225 105

Inline code

Délimité par 1 backquotes. Insérable dans une zone de texte

Le tableau contient `r nrow(mtcars)` 
lignes et `r ncol(mtcars)` colonnes.

- **Moyenne** = `r mean(mtcars$drat)`
- **Médiane** = `r median(mtcars$drat)`

Le tableau contient 32 lignes et 11 colonnes.

  • Moyenne = 3.5965625
  • Médiane = 3.695

Options des blocs de code (ex R)

Le comportement des chunks sont paramétrables.



Les options élémentaires disponibles sont identiques en Rmarkdown et Quarto.


Quarto propose des options supplémentaires. Plus d’infos :


Options des blocs de code -Exemple


Exemple 1 (Rmarkdown) :
```{r, eval=TRUE, echo=FALSE, message=FALSE, warning=FALSE, fig.align=center, out.width = 30%}

plot(1:10)

```


Exemple 2 (Quarto - pipe):
```{r}
#| eval: TRUE
#| echo: FALSE
#| message: FALSE
#| warning: FALSE
#| fig.align: center
#| out.width: 30%

plot(1:10)

```


Exemple 3 (Méthode mixte) :
```{r, eval=TRUE, echo=FASLE, message=FALSE}
#| warning: FALSE
#| fig.align: center
#| out.width: 30%

plot(1:10)

```


  • eval: TRUE → le bloc de code sera exécuté. 
  • echo: FALSE → le bloc de code ne sera pas affichés. 
  • message: FALSE → Les messages renvoyés ne seront pas affichés. 
  • warning: FALSE → Les warnings renvoyés ne seront pas affichés.
  • fig.align: center → Les représentations graphiques générées seront centrées sur la page. 
  • out.width: 30% → Les représentations graphiques générées seront dimensionnées à 30% de la page.


Résultat en sortie :

Premiers pas avec Rmarkdown

Premier pas avec Rmarkdown

  1. Créez un nouveau projet Rstudio
  2. Créez un nouveau fichier.rmd (sortie html) → Menu File > New File > R Markdown...

Premier pas avec Rmarkdown

  1. Enregistrez ce fichier.rmd à la racine de votre projet Rstudio.

Premier pas avec Rmarkdown

  1. Knitez le document Rmd.

🧶 Tricot d’un Rmarkdown ?

Pandoc est généralement pré-installé sur les systèmes d’exploitation MACOS et Windows.
Si vous n’avez pas \(\LaTeX\) d’installé, utilisez le package tinytex pour la compilation en pdf.

Premier pas avec Rmarkdown

  1. Pour ajouter un nouveau chunk, positionnez le curseur dans le document puis cliquez sur :

Premier pas avec Rmarkdown

  1. Mettez en page ce bout de programme dans votre document Rmarkdown :
#------------------------------------------------------------------------#
#       Titre: Fonctions R-base & package ggplot2
#       Sous-titre: Fonctions R-base & package ggplot2
#       Auteur : Vous
#       Date: courante
#------------------------------------------------------------------------#

# Partie 1. Discrétisation la variable Sepal.Length (données iris) ------#

## 1.2. Statistiques sur la série statistique 'Sepal.Length'
#### -> Montrez seulement la sortie graphique
summary(iris$Sepal.Length)

## 1.3. Histogramme de la distribution
hist(iris$Sepal.Length)

## 1.4. Choix des bornes de classes (amplitude égale)
bornes_des_classes <- c(min(iris$Sepal.Length), 5, 6, 7, 
                        max(iris$Sepal.Length))

## 1.5. Choix des noms de classes
nom_des_classes <- c("Trés petites","petites","grandes","Très grandes")

## 1.6. Discrétisation de la variable 'Sepal.length'
iris$classe  <- cut(iris$Sepal.Length,
                    breaks = bornes_des_classes,
                    labels = nom_des_classes,
                    include.lowest = TRUE)

# Partie 2. Représentation de la distribution selon la discrétisation ---#

## 2.1. Bibliothèque pour la représentation graphique
library(ggplot2)

## 2.2. Représentation graphique de la distribution
ggplot(data = iris, aes(x = classe)) +  # Choix des données et de la variable à représenter
  geom_bar() +  # Choix du type de représentation
  xlab("") +    # Suppression du nom de l'axe x
  ylab("") +    # Suppression du nom de l'axe y
  ggtitle("Répartition par classe") +  # Titre du graphique
  theme(plot.title = element_text(size=27),  # Taille de la police titre 
        axis.text=element_text(size=19))     # Taille des labels d'axe

Consignes :

  • Insérez les métadonnées (titre, auteur…) dans le YAML.

  • Structurez en partie (#) et commentez le hors des chunks.

  • Isolez chaque fonction dans un chunk unique.

  • L’ensemble des chunks doivent être exécutés.

  • Masquez les chunk (echo) des parties 1.2, 1.3 et 2.1.

  • Dimensionnez le plot généré (2.2) à 50% (out.width)

  • Centrez le plot généré (fig.align).

  • Ajoutez la numérotation automatique des parties (number_sections dans le YAML).


Corrections :

Premier pas avec un template

Les modèles de mise en page (template) Rmarkdown sont fournis via des packages. Il en existe beaucoup, que ce soit pour de simple document(PDF, HTML…), un article, un livre, une thèse, un diaporama, un tutoriel ou encore un site web statique.

Quelques exemples : bookdown, distill, flexdashboard, hrbrthemes, komadown, komaletter, learnr, linl, memor, pagedown, papaja, pinp, prettydoc, radix, revealjs, rmarkdown, rmdformats, rmdshower, rticles, rzine, tufte, unilur, vitae, xaringan

Une fois le package installé. Il est possible d’appeler le template dans le YAML à l’aide de la variable output.


Exemple : utilisation du modéle de mise en page readthedown du package rmdformats (Barnier, 2017) :

install.packages("rmdformats")

Appel du template de mise en page readthedown dans le YAML :

---
title: "Template readthedown proposé par le package rmdformats"
date: "2023-02-21"
output:
  rmdformats::readthedown:
    highlight: kate
---

Premier pas avec un template

  1. Installez le package rmdformats.
install.packages("rmdformats")


  1. Créez un nouveau fichier.Rmd avec le modèle de mise en page readthedown.
    Menu File > New File > R Markdown > From Template...




Premier pas avec un template

  1. Transférez votre premier document créé dans le template readthedown, puis knitez.

Corrections → Fichier Rmd / sortie HMTL

?

Quarto est un nouveau système open-source de publication d’articles scientifiques et techniques basé sur Pandoc. C’est un outil orienté LP, plus moderne que le Rmarkdown et facilement adaptable à différents cadres d’utilisations.

Il permet d’exploiter différents langages de programmation tels que R, Python, Julia ou JavaScript.

Quarto unifie et étend les fonctionnalités offertes par les différents notebooks existant, plus particulièrement les extensions Rmarkdown.

Quarto est développé par Posit™️ (Rstudio). Cependant, le périmètre d’utilisation de ce système s’étend au delà de la communauté R.

Quarto peut être installé et utilisé de différentes manières :

Au délà de proposer un système performant et complet pour la production de documentations scientifiques et techniques, Quarto tente également de rendre la pratique des documents computationnels plus accessible.

Quel avenir pour le Rmarkdown ?


Rmarkdown restera à moyen terme supporté par Posit™ (Rstudio), mais les efforts de développement seront concentrées sur Quarto. Cela risque de se répercuter sur la communauté des utilisateurs : le développement et la maintenance d’extensions Rmardkown devraient ralentir.




Pas de panique : la conversion ou la migration vers quarto est simple !

Que peut-on faire avec Quarto ?


Quarto propose directement 4 types de publications possibles :

  • des articles ou rapports (HTML, PDF, MS Word, ePub…)
  • des présentations (Revealjs, PowerPoint, Beamer)
  • des livres ou manuel (HTML, PDF, MS Word, ePub…)
  • des sites web


À ce jour, peu de modèles de mise en page et d’extensions ont été développés. Néanmoins,le système Quarto propose directement toutes les fonctionnalités suffisantes pour créer un document scientifique de qualité (ex: équations, citations, références croisées, table des matière, des figures, note de bas de page, mise en page avancée, et même de l’interactivité pour les diaporama).

Quoi de neuf par rapport au Rmarkdown ?


De manière générale :

  • Multi-langage (Julia, Python, R, Observable),
  • De nouvelles options d’interactivité (notamment pour le format présentation),
  • Publication des sites web facilité,
  • Conversion d’un type de publication vers un autre facilité (ex : document -> presentation) .

Des fonctionnalités de mise en page plus avancées :

  • 25 thèmes bootswatch inclus (https://bootswatch.com/) ,
  • De nouvelles options de mise en page* (gestion des marges, column layout),
  • Extension markdown “fenced_divs pour la création de div (comme HTML),
  • Fonctionnalité de création d’onglet (tabset).

Avec L’IDE Rstudio :

  • Outil de prévisualisation de la mise en page,
  • Fonctionnalités d’aide à la mise en page (style Microsoft Word).

De nouvelles options pour la gestion des blocs de code, exemples :

  • Option “freeze” qui permet de réexecuter uniquement les blocs de code modifiés,
  • Option “code-link” : lien hypertexte entre les fonctions affichées et leur documentation,
  • Option “code-copy” : ajoute un bouton permettant de copier le code source d’un chunk,
  • Option “code-fold”. Le lecteur peut masquer/demasquer un bloc de code avec un simple clic,
  • Option “code-tools” : fournit des outils permettant aux lecteurs d’interagir avec le code source.

Notebook polyglotes

A. Import et affichage d’un fond de carte
library("sf")
countries <- st_read("data/countries.gpkg", quiet = T)
plot(st_geometry(countries))


B. Import et affichage d’un tableau statistique
data <- read.csv("data/stat.csv")
head(data)
   id                 name  region      pop          gdp    gdppc year
1 AFG          Afghanistan    Asia 38928341  19807067268   508.81 2020
2 AGO               Angola  Africa 32866268  62306913444  1895.77 2020
3 ALB              Albania  Europe  2837743  14799615097  5215.28 2020
4 AND              Andorra  Europe    77146   3155065488 40897.33 2019
5 ARE United Arab Emirates    Asia  9770526 421142267937 43103.34 2019
6 ARG            Argentina America 45376763 383066977654  8441.92 2020

Notebook polyglotes

C. Jointure fond de carte - tableau (R)

world <- merge(countries, data, by.x = "ISO3", by.y = "id")


D. Transformation de données en GeoJson (R)

library(geojsonsf)
ojs_define(world_string = sf_geojson(world))

E. Import des données GeoJson

F. Chargement des librairies nécessaires


G. Construction de l’interface


Création d’onglets

Syntaxe markdown pour la création de tabset :

::: panel-tabset 

## Julia
![](img/Julia.png){width=30%}

## Python
![](img/python.png){width=30%}

## R
![](img/R.png){width=30%}

## observable
![](img/observable.png)

:::


Rendu graphique :

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat <- 48.90717808167005
lng <- 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives


Line Highlighting (code-line-numbers) :


library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Des présentations + interactives



menu: TRUE - whiteboard: TRUE - chalkboard: TRUE



Pointer

Des présentations + interactives

Auto animate

Des présentations + interactives

Auto animate

Des présentations + interactives


Auto animate & code animations

library(sf)
library(leaflet)

Des présentations + interactives


Auto animate & code animations

library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 

Des présentations + interactives


Auto animate & code animations

library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

Des présentations + interactives


Auto animate & code animations

library(sf)
library(leaflet)

##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)

Démarrer avec Quarto

Créer un notebook Quarto

Quarto est directement integré dans les dernière version de Rstudio.
Pour installer la dernière version de Rstudio : https://posit.co/download/rstudio-desktop/


Exemple 1 : Créer un Quarto Document ou une Quarto présentation : File > New File > Quarto...

Avertissement

Un Quarto document ou présentation = Un seul fichier .qmd


Exemple 2 : Créer un Quarto wesite ou Quarto Book : File > New Project > New Directory > ...

Avertissement

Un Quarto book ou website = Plusieurs fichiers .qmd. Un fichier par chapitre ou page du site.

_quarto.yml

Tous les projets Quarto comprennent un fichier de configuration _quarto.yml. Cela concerne donc obligatoirement les Quarto books et les Quarto websites.

Tout document compilé (Render) dans le répertoire du projet héritera automatiquement des métadonnées définies au niveau du projet. Le fichier de projet contient à la fois des options globales qui s’appliquent à tous les formats (par exemple TOC et bibliographie) et des options spécifiques à chaque format. Voici un exemple de fichier _quarto.yml :

_quarto.yml
project:
  output-dir: _output

toc: true
number-sections: true
bibliography: references.bib  
  
format:
  html:
    css: styles.css
    html-math-method: katex
  pdf:
    documentclass: report
    margin-left: 30mm
    margin-right: 30mm


Il s’agit en quelque sorte d’une en-tête (YAML) globale pour tout le repértoire.
Cela n’empêche pas que chaque fichier .qmd du projet contient également sa propre en-tête (YAML)

Compiler un Quarto

=


Il est possible d’utiliser jupyter pour la compilation.

Exercice

A. Créez un nouveau projet Quarto book. File > New Project > New Directory > Quarto Book...

Compilez-le en HTML : Render Book

Exercice

Un peu d’aide ?

Aidez-vous de la documentation Quarto : https://quarto.org/docs/guide/


B. Paramétrage du fichier _quarto.yml

  1. Ajouter les métadonnées principales : titre, sous-titre, nom de l’auteur et affiliations, date… Puis Render en HTML

Exemple :

_quarto.yml
book:
  title: "Mon premier quarto book"
  subtitle: "Et j'en suis très fier..."
  date: "03/10/2023"
  author:
  - name: Hugues pecout
    orcid: 0000-0002-0246-0954
    affiliations:
      - name: CNRS
      - name: UMR Géographie-Cités


  1. La langue du quarto est l’anglais par défault. Modifiez la langue pour le français :
_quarto.yml
lang: fr    


  1. Modifier le theme utilisé par défault (cosmo). Pour choisir un théme :

Exemple :

_quarto.yml
format:
  html:
    theme: sketchy


  1. Supprimez le numérotage des sections
_quarto.yml
format:
  html:
    number-sections: false


  1. Activez l’affichage d’un image de couverture (uniquement sortie HTML et epub). et modifiez la par le logo d’ElementR.
_quarto.yml
format:
  html:
    theme: sketchy
    embed-resources: true
    cover-image: ElementR.png

 

Votre document compilé en HTML devrait ressembler à cela (thème sketchy) :

Exercice

C. Ajoutez un nouveau chapitre

  1. Créez un nouveau fichier .qmd à la racine de votre projet

  1. Ajoutez-lui un titre de niveau 1 (#) en markdown

  1. Ajoutez le chapitre dans le fichier _quarto.yml pour qu’il apparaisse dans la table des matières


Votre document compilé en HTML devrait ressembler à cela :

Exercice

D. Ajouter du contenu (https://quarto.org/docs/authoring/markdown-basics.html)

Ajoutez du contenu dans votre nouveau chapitre : Titre, texte mis en forme, image, équation, vidéo, bloc de code, note de bas de page, citation, diagramme, équation….


Quelques exemples :


Titre & liste

# Ma partie 1

## Introduction 

Cette partie de ma thèse est sans doute la meilleure car :

- **Ma directrice le pense**
- Elle n'est **pas encore rédigée**

Ma partie 1

Introduction

Cette partie de ma thèse est sans doute la meilleure car :

  • Ma directrice le pense
  • Elle n’est pas encore rédigée


Citation & note de bas de page

## Citation

> *L'histoire n'est que la géographie dans le temps, comme la géographie n'est que l'histoire dans l'espace.*
>
> Elisée Reclus


## Note de bas de page

L'ontologie[^1] est une branche de la philosophie et plus spécifiquement de la métaphysique qui, dans son sens le plus général, s'interroge sur la signification du mot « être ».

[^1]: Perso, je n'ai jamais compris

Citation

L’Histoire n’est que la Géographie dans le temps, comme la géographie n’est que l’histoire dans l’espace.

Elisée Reclus

Note de bas de page

L’ontologie1 est une branche de la philosophie et plus spécifiquement de la métaphysique qui, dans son sens le plus général, s’interroge sur la signification du mot « être ».


Tableau en markdown

## Tableau en markdown

| Variable   |   Avignon  |  Lorient  |  calais  |
|:----------:|:----------:|:---------:|:--------:|
|   Pop      |   90 597   |  57 412   |  67 544  |
|   sup      |   64,78    |  17,48    |   33,5   |
Variable Avignon Lorient calais
Pop 90 597 57 412 67 544
sup 64,78 17,48 33,5


Équation mathématique

## Equation mathématique (LaTeX)

$$x_{1,2} = \frac{- b \pm \sqrt{\Delta}}{2a}$$

\[x_{1,2} = \frac{- b \pm \sqrt{\Delta}}{2a}\]


Diagramme

```{mermaid}
flowchart LR
  A[État de l art] --> B(Terrains)
  B --> C{Analyses}
  C --> D[Communications]
  C --> E[Rédaction de la thèse]
```
flowchart LR
  A[État de l art] --> B(Terrains)
  B --> C{Analyses}
  C --> D[Communications]
  C --> E[Rédaction de la thèse]


Image

## Inclure une image

![](img/ElementR.png){width="20%"}


Vidéo

## Inclure une vidéo 



Bloc de code & inline code

```{r}
valeur <- round(mean(c(64.78, 17.48, 33.5)),2)
```

Pour inclure le contenu d’un objet R directement dans une zone de texte :

Pour inclure le contenu d'un objet R directement dans une zone de texte : 38.59 


Référence bibliographique

La référence bibliographique doit être renseignée dans un fichier.bib (ex : cf. le fichier reference.bib à la racine du répertoire). Plus de détail sur cette page.

Il est très simple de faire référence à de la bibliographie en markdown. Ex : [@bertin1967]

Il est très simple de faire référence à de la bibliographie en markdown. Ex : (Bertin 1967)


Note, warning…

:::{.callout-warning}
## Précautions d'usages
Bla bla bla bla
:::

:::{.callout-note}
## Ceci est une note
Bla bla bla bla
:::

:::{.callout-important}
## Ceci est important
Bla bla bla bla
:::

Précautions d’usages

Bla bla bla bla

Ceci est une note

Bla bla bla bla

Ceci est important

Bla bla bla bla


Markdown avancé (div)

::: {.panel-tabset} 

## Doctorant·es
![](img/doc.jpg)

## Maître·sse de conférence
![](img/mcf.jpg)

## Professeur·e
![](img/prof.jpg)

:::


Votre document prend forme :


Télécharger un exemple complet de chapitre (.qmd) mis en forme : ici


Programmation lettrée, notebook et reproductibilité

Programmation lettrée + Notebook = 🔥

Programmation lettrée

Notebook

Programmation lettrée + Notebook = 🔥


Reproductibilité ?

LP + NB + … ? = reproductibilité

Programmation lettrée

Notebook

Informations de session
et d’environnement

Mise à disposition
Conditions d’utilisation

LP + NB + … ? = reproductibilité

Quel outil pour le partage ?


Git, GitLab & GitHub


Git est un système de gestion de version distribué pour :

  • tracker les changements dans les fichiers texte
  • gérer l’historique du code source
  • partager le code dans des dépots distants


GitLab et GitHub sont des services web d’hébergement et de gestion de version (issue tracker, collaboration, hébergement web, CI/CD), qui reposent sur le logiciel de version Git.

Notebook + GitLab (ou GitHub) = 🔥🔥🔥

  1. Sources des notebooks = fichiers texte

➡️ Suivi des modifications (commit, branches, etc.) 
➡️ Partage des fichiers sources (dépôt public ou privé)


  1. GitLab et GitHub permettent de compiler un notebook

➡️ Continuous Integration


  1. GitLab et GitHub permettent de déployer (mise en ligne) un notebook HTML

➡️ Continuous Deployment

Un exemple ?

Ceci est un notebook…

Chunk de code R (exécuté et affiché) :

##------------------------ PACKAGES utilisés --------------------------## 

# install.packages("sf")
# install.packages("leaflet")

# Chargement des librairies
library(sf)
library(leaflet)



##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées du Centre des colloques du Campus Condorcet
lat = 48.90717808167005
lng = 2.3665081750584123
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Campus Condorcet")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)



##--------------------- Création carte dynamique ----------------------## 

# Lien vers une photo de l'IRSP
file <- 'https://www.campus-condorcet.fr/medias/photo/vincentbourdon8a2528_1607697136983-jpg?ID_FICHE=4599'

# Construction du marker
icons <- awesomeIcons(icon = 'ios-people',
                      iconColor = 'white',
                      library = 'ion',
                      markerColor = 'blue')


# Affichage du point - carte interactive
mamap <- leaflet(Here) %>%
            setView( lat = lat, lng = lng, zoom = 13) %>% 
            addProviderTiles("GeoportailFrance.orthos") %>%
            addAwesomeMarkers(icon = icons,
                              popup = paste("<img src =", file, ">", 
                                            "<p style='text-align:center;'>Centre des Colloques</br>du Campus Condorcet</a></p>"))

Ceci est un notebook…

Affichage du résultat :

Partagé et open source !


Notebook Quarto - Revealjs presentations

Code source sur GitLab Huma-Num : https://gitlab.huma-num.fr/elementr/session_notebook/programmation_lettree
Page GitLab déployée : https://elementr.gitpages.huma-num.fr/session_notebook/programmation_lettree/#/title-slide


Informations session

sessionInfo()
R version 4.3.1 (2023-06-16 ucrt)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 11 x64 (build 22621)

Matrix products: default


locale:
[1] LC_COLLATE=French_France.utf8  LC_CTYPE=French_France.utf8   
[3] LC_MONETARY=French_France.utf8 LC_NUMERIC=C                  
[5] LC_TIME=French_France.utf8    

time zone: Europe/Paris
tzcode source: internal

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] leaflet_2.1.2   geojsonsf_2.0.3 sf_1.0-13       ggplot2_3.4.2  

loaded via a namespace (and not attached):
 [1] gtable_0.3.3            jsonlite_1.8.7          dplyr_1.1.2            
 [4] compiler_4.3.1          tidyselect_1.2.0        Rcpp_1.0.11            
 [7] scales_1.2.1            yaml_2.3.7              fastmap_1.1.1          
[10] R6_2.5.1                labeling_0.4.2          generics_0.1.3         
[13] classInt_0.4-9          knitr_1.43              htmlwidgets_1.6.2      
[16] tibble_3.2.1            leaflet.providers_1.9.0 units_0.8-2            
[19] munsell_0.5.0           DBI_1.1.3               pillar_1.9.0           
[22] rlang_1.1.1             utf8_1.2.3              xfun_0.39              
[25] cli_3.6.1               withr_2.5.0             magrittr_2.0.3         
[28] crosstalk_1.2.0         class_7.3-22            digest_0.6.32          
[31] grid_4.3.1              rstudioapi_0.14         lifecycle_1.0.3        
[34] vctrs_0.6.3             KernSmooth_2.23-21      proxy_0.4-27           
[37] evaluate_0.21           glue_1.6.2              farver_2.1.1           
[40] fansi_1.0.4             e1071_1.7-13            colorspace_2.1-0       
[43] rmarkdown_2.23          ellipsis_0.3.2          tools_4.3.1            
[46] pkgconfig_2.0.3         htmltools_0.5.5        

Licence Etalab

A vous de jouer !


Enough Markdown to Write a Thesis…

Bertin, Jacques. 1967. Sémiologie Graphique. Les Diagrammes - Les Réseaux - Les Cartes. Paris: Mouton & Gauthier-Villars.