Discussion :

[Amergin]

Salut tous,

Une question simple: j'ai une table dont je voudrais appeler certains éléments. Mais je voudrais également pouvoir appeler cette même table à quelques petites variations près, sans en créer une nouvelle.

Par exemple dans tab, je veux pouvoir appeler tab.(i) pour tous les i sauf k que je voudrais remplacer par une autre valeur.

Et pour ça, je range dans une petite table les éléments qui varient, et ce par quoi il faut les remplacer.

Je vois bien comment faire ça salement (je veux dire comme je le ferais en impératif), mais j'imagine que c'est typiquement le genre de choses qu'on peut faire très joliment avec Ocaml, alors est-ce que quelqu'un aurait une suggestion?

Merci d'avance!

[Cacophrene]

Salut !

Je n'ai pas tout bien compris donc je ne te garantis pas ce qui va suivre.

Si tu veux appliquer une fonction f à tous les éléments d'un tableau sauf quelques-uns dont tu veux d'abord modifier la valeur, et le tout sans créer de nouveau tableau, tu peux faire quelque chose comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
let rep_iter f tbl modi =
  Array.iteri (fun i x ->
    let x' = try 
      let y = List.assoc i modi in 
      tbl.(i) <- y;
      y 
    with Not_found -> x in f x'
  ) tbl

Cette fonction reçoit en entrée une fonction (f), une table (tbl) et une liste de valeurs à modifier sous forme de couples index * valeur (modi). Sinon il y a aussi Array.map mais ça crée un nouveau tableau.

Ça fait quand même très curieux (et s...) de faire des effets de bord sur une structure dans un itérateur sur cette même structure.

Cordialement,
Cacophrène

[Amergin]

Ça fait quand même très curieux (et s...) de faire des effets de bord sur une structure dans un itérateur sur cette même structure.

Le dogme des programmeurs c'est quelque chose que j'ai toujours du mal à saisir: effet de bord cela veut dire une modif locale? Pourquoi est-ce si choquant de combiner cela à une iteration?
En tous cas, c'est bien le genre de chose que je voulais faire, là c'est quand même beaucoup plus compact. Merci!

[LLB]

Un effet de bord, c'est plutôt une modification "globale" (qui a des répercussions en dehors de ton expression). Là, ton expression modifie le tableau.

Pour trouver ça curieux, il faut ne pas être habitué à l'impératif.

[gasche]

Pour pouvoir proposer une structure de donnée adaptée, il faudrait qu'on ait plus d'information sur l'usage que tu fais.

- Quelle est environ la taille des tableaux que tu considères ? Quelle proportion des éléments seront amenés à varier ?

- Un élément peut-il varier plusieurs fois ? Es-tu intéressé par tous les tableaux intermédiaires, ou juste le premier et le dernier ? Lequel / lesquels vas-tu utiliser le plus par la suite ?

Le mieux serait carrément de nous décrire en deux mots le scénario d'usage de cette histoire.

Sais-tu qu'il existe une structure de donnée déjà toute faite en OCaml, Map, qui permet un accès aux données relativement rapide (accès en O(log n), donc un peu moins bien qu'un tableau en O(1) mais quand même pas mal) et supporte déjà ce que tu veux (mise à jour d'une map en temps constant, sans modifier la map précédente) ? Si oui, pourquoi as-tu choisi de ne pas t'en servir ?

[Amergin]

- Quelle est environ la taille des tableaux que tu considères ? Quelle proportion des éléments seront amenés à varier ?

C'est très variable, mais disons minimum 50, maximum plusieurs milliers pour la taille du tableau; quelques unités étant amenées à varier (c'est pour ça que je ne voulais pas en construire un nouveau à chaque fois).

-Un élément peut-il varier plusieurs fois ? Es-tu intéressé par tous les tableaux intermédiaires, ou juste le premier et le dernier ? Lequel / lesquels vas-tu utiliser le plus par la suite ?

Le mieux serait carrément de nous décrire en deux mots le scénario d'usage de cette histoire.

En fait je fais un test à chaque étape, si mon test réussit je garde le tableau modifié, s'il échoue je retourne à la forme précédente.

Sais-tu qu'il existe une structure de donnée déjà toute faite en OCaml, Map, qui permet un accès aux données relativement rapide (accès en O(log n), donc un peu moins bien qu'un tableau en O(1) mais quand même pas mal) et supporte déjà ce que tu veux (mise à jour d'une map en temps constant, sans modifier la map précédente) ? Si oui, pourquoi as-tu choisi de ne pas t'en servir ?

Ah! je connais map, mais je ne savais pas que c'était si efficace, je pensais que cela revenait en gros à créer une nouvelle table.
Cela dit, la structure de Cacophrene, adaptée à mon problème est simple et fonctionne bien.

[Cacophrene]

Re !

Le dogme des programmeurs c'est quelque chose que j'ai toujours du mal à saisir

Point de dogme ou de réflexe d'école ici... c'était juste de l'humour (cf. smiley). D'autant que l'informatique n'est pas mon domaine de formation.

Pour trouver ça curieux, il faut ne pas être habitué à l'impératif.

Je ne suis pas de cet avis. Pour trouver ça curieux, il suffit de remarquer qu'on aurait pu écrire une boucle, tout simplement, ce qui n'est pas le cas ici. Le mélange d'un itérateur par nature fonctionnel avec la modification de la structure itérée elle-même (il ne s'agit donc pas d'un effet de bord quelconque) a quand même un peu d'originalité !

Ceci étant cela ne change rien à la question d'Amergin.

Cordialement,
Cacophrène

PS : Au sens où je l'emploie (le sens du dico, me semble), curieux n'est pas choquant.

[LLB]

Pour trouver ça curieux, il suffit de remarquer qu'on aurait pu écrire une boucle, tout simplement, ce qui n'est pas le cas ici.

C'est équivalent, il n'y a que la syntaxe qui change.
Dans les langages impératifs, il est courant que la boucle for repose sur des itérateurs, et ce n'est pas forcément en lecture seule (regarde le C++ par exemple). Ce qui est plus "curieux", c'est de supprimer un élément lors de l'itération (mais ce n'est pas possible en Caml).

Amergin : si tu as besoin d'accéder à l'ancienne valeur de ton tableau, tu dois faire une copie, ce qui peut être assez coûteux (estimer d'estimer si tu devras faire souvent des copies : si oui, change de structure !).

[Cacophrene]

Salut !

C'est équivalent, il n'y a que la syntaxe qui change.
Dans les langages impératifs, il est courant que la boucle for repose sur des itérateurs, et ce n'est pas forcément en lecture seule (regarde le C++ par exemple). Ce qui est plus "curieux", c'est de supprimer un élément lors de l'itération (mais ce n'est pas possible en Caml).

Autant pour moi alors.

Cordialement,
Cacophrène