Merge branch 'master' of ssh://ssh.hesge.ch:10572/programmation_sequentielle/cours

slides/metadata.yaml

 ---
 subtitle: "Programmation séquentielle en C, 2022-2023"
-author: "Orestis Malaspinas (A401)"
+author: "Orestis Malaspinas (A401) et un tout petit peu Michaël El Kharroubi"
 institute: "Informatique et Systèmes de Communication, HEPIA"
 lang: fr-CH
 revealjs-url: /reveal.js

slides_2022/fonctions_dordre_superieur.md

@@ -135,9 +135,9 @@ 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 `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`
+    * `L + R -> + L R`
+    * `L - R -> - L R`
+    * `L * R -> * L R`
 
 * Comment l'implémenter concrètement en C?
 
@@ -153,20 +153,23 @@ vec3 apply_operator(operator op, vec3 lhs, vec3 rhs);
 
 * 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.
 
-# Rappel pointeur de fonctions
+# Pointeur de fonctions
 
 * Un pointeur de fonction se définit ainsi
 
-```c
-typedef 
+    ```c
     <type retour> (*<nom ptr fonc>)(<type params(s)>);
-```
+    ```
+* Ou encore avec un `typedef`
 
+    ```c
+    typedef <type retour> (*<nom ptr fonc>)(<type params(s)>);
+    ```
 * 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 (*operator)(double, double);
-```
+    ```c
+    typedef double (*operator)(double, double);
+    ```
 
 # Implémentation (suite)
 
@@ -188,7 +191,6 @@ vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
 
 ```c
 typedef double (*operator)(double, double);
-
 vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
     vec3 res;
     res.x = op(lhs.x, rhs.x);
@@ -196,9 +198,9 @@ vec3 apply_operator(operator op, vec3 lhs, vec3 rhs){
     res.z = op(lhs.z, rhs.z);
     return res;
 }
-
-double add_dbl(double lhs, double rhs){return lhs + rhs;}
-
+double add_dbl(double lhs, double rhs){
+    return lhs + rhs;
+}
 vec3 add(vec3 lhs, vec3 rhs){
     return apply_operator(add_dbl, lhs, rhs);
 }
@@ -214,3 +216,62 @@ vec3 add(vec3 lhs, vec3 rhs){
     * Reduce (réduction d'un vecteur à un seul élément)
         * `sum`, `multiply`
         
+# Le map
+
+* Exemple d'application
+
+    ```c
+    typedef double (*operator)(double);
+    double *map(operator op, double *tab, size_t size) {
+        double *res = malloc(sizeof(*res) * size);
+        for (int i = 0; i < size; ++i) {
+            res[i] = op(tab[i]);
+        }
+        return res;
+    }
+    double add_one(double val) {
+        return val + 1;
+    }
+    double sqr(double val){
+        return val * val;
+    }
+    double tab[] = {1.0, 2.0, 3.0};
+    double *square = map(sqr, tab, 3);
+    double *and_one = map(add_one, square, 3);
+    ```
+
+# Le map
+
+* Permettrait le chaînage.
+
+    ```C
+    double *sqr_and_one = map(add_one, map(sqr, tab, 3), 3);
+    ```
+. . .
+
+* Problème?
+
+. . .
+
+* Allocation dynamique... fuite mémoire.
+
+. . .
+
+* Solution?
+
+. . .
+
+    ```c
+    typedef double (*operator)(double);
+    double *map(operator op, double *tab, size_t size) {
+        double *res = malloc(sizeof(*res) * size);
+        for (int i = 0; i < size; ++i) {
+            res[i] = op(tab[i]);
+        }
+        free(tab);
+        return res;
+    }
+    ```
+
+* Problème potentiel?
+* **Attention au double free!**