Applied @orestis.malaspin corrections.

slides/fonctions_dordre_superieur.md

@@ -87,7 +87,7 @@ vec3 mul(vec3 lhs, vec3 rhs){
 ```c
 typedef struct _vecn {
     int size;
-    double* xs;
+    double *xs;
 } vecn;
 ```
 
@@ -95,12 +95,13 @@ typedef struct _vecn {
 
 # Fonction d'ordre supérieur (solution au problème)
 
-* Pour notre problème, nous aimerions donc découpler l'opération binaire (opération entre deux termes : +,-,*) de l'itération sur les composantes.
+* Pour notre problème, nous aimerions donc découpler l'opération (opération entre deux termes : +,-,*) de l'itération sur les composantes.
 
 * Ce qui nous donne conceptuellement en pseudo c
 
 ```c
-vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
+// Attention pseudo c, ne compile pas !!!!!
+vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
     vec3 res;
     res.x = lhs.x op rhs.x;
     res.y = lhs.y op rhs.y;
@@ -111,17 +112,18 @@ vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
 
 # Fonction d'ordre supérieur (solution au problème)
 
-* Avec notre fonction conceptuelle `apply_binop`, on pourrait faire 
+* Avec notre fonction conceptuelle `apply_operator`, on pourrait faire (toujours en pseudo c)
 
 ```c
+// Attention pseudo c, ne compile pas !!!!!
 vec3 add(vec3 lhs, vec3 rhs){
-    return apply_binop(+, lhs, rhs);
+    return apply_operator(+, lhs, rhs);
 }
 vec3 sub(vec3 lhs, vec3 rhs){
-    return apply_binop(-, lhs, rhs);
+    return apply_operator(-, lhs, rhs);
 }
 vec3 mul(vec3 lhs, vec3 rhs){
-    return apply_binop(*, lhs, rhs);
+    return apply_operator(*, lhs, rhs);
 }
 ```
 
@@ -131,7 +133,7 @@ vec3 mul(vec3 lhs, vec3 rhs){
 
 * Une fonction d'ordre supérieur est une fonction qui prend en paramètre et/ou retourne une(des) autre(s) fonction(s).  
 
-* Si on essayait de définir `binop`, c'est en fait une fonction qui prend deux paramètres (un terme de gauche et un terme de droite). On s'en aperçoit clairement avec la notation préfix (polonaise).
+* Si on essayait de définir `operator`, c'est en fait une fonction qui prend deux paramètres (un terme de gauche et un terme de droite). On s'en aperçoit clairement avec la notation préfix (polonaise).
     * `L + R` -> `+ L R`
     * `L - R` -> `- L R`
     * `L * R` -> `* L R`
@@ -143,10 +145,10 @@ vec3 mul(vec3 lhs, vec3 rhs){
 * Si on reprend la signature de notre fonction d'exemple, on a
 
 ```c
-vec3 apply_binop(binop op, vec3 lhs, vec3 rhs);
+vec3 apply_operator(operator op, vec3 lhs, vec3 rhs);
 ```
 
-* Nous avons déterminé que les `binop` étaient des fonctions qui prennaient deux paramètres.
+* Nous avons déterminé que les `operator` étaient des fonctions qui prennaient deux paramètres.
 
 * Pour passer une fonction en paramètre en C, nous devons la passer par référence, c'est à dire à l'aide d'un pointeur de fonction.
 
@@ -159,18 +161,18 @@ typedef
     <type retour> (*<nom ptr fonc>)(<type params(s)>);
 ```
 
-* Dans notre cas, nous avons donc un type de fonction nommé `binop`, qui prend en entrée deux `double`{.c} et qui retourne un `double`{.c}. Ce qui nous donne 
+* Dans notre cas, nous avons donc un type de fonction nommé `operator`, qui prend en entrée deux `double`{.c} et qui retourne un `double`{.c}. Ce qui nous donne 
 
 ```c
-typedef double (*binop)(double, double);
+typedef double (*operator)(double, double);
 ```
 
 # Implémentation (suite)
 
-* En reprenant notre fonction `apply_binop`, on a donc
+* En reprenant notre fonction `apply_operator`, on a donc
 
 ```c
-vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
+vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
     vec3 res;
     res.x = op(lhs.x, rhs.x);
     res.y = op(lhs.y, rhs.y);
@@ -184,9 +186,9 @@ vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
 # Résultat
 
 ```c
-typedef double (*binop)(double, double);
+typedef double (*operator)(double, double);
 
-vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
+vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
     vec3 res;
     res.x = op(lhs.x, rhs.x);
     res.y = op(lhs.y, rhs.y);
@@ -197,6 +199,17 @@ vec3 apply_binop(binop op, vec3 lhs, vec3 rhs){
 double add_dbl(double lhs, double rhs){return lhs + rhs;}
 
 vec3 add(vec3 lhs, vec3 rhs){
-    return apply_binop(add_dbl, lhs, rhs);
+    return apply_operator(add_dbl, lhs, rhs);
 }
 ```
+
+# Fonctions d'ordre supérieur appliquées aux tableaux
+
+* Comment appliquer des opérations sur un vecteur de taille n?
+    * Map (application d'une fonction)
+        * `add_one`, `square`
+    * Filter (discrimination selon un prédicat)
+        * `is_even`, `is_lower_than_five`
+    * Reduce (réduction d'un vecteur à un seul élément)
+        * `sum`, `multiply`
+        
\ No newline at end of file