Discussion :

[darkontes]

bonjour bonjour
voila je cherche, avec camllight, à programmer un jeu de la vie. pour cela j'ai besoin d'une fonction qui permet de compter le nombre de voisins vivants en une case de la matrice, de plus je dois faire au final un jeu de la vie dans un monde torique ( cf ma fonction "aux" plus bas )
pour l'instant voila ce que j'ai fait :
je considere g la matrice de taille (n*p) et je cherche le nombre de voisins vivants a la case de coordonnées (i,j) et je considere qu'une cellule vivante contient un 1 et une morte un 0

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let nb_voisins g n p i j =
 let rec aux = function 
  |(-1,a)->aux(n-1,a)
  |(n,b)->aux(0,b)
  |(c,-1)->aux(c,p-1)
  |(d,p)->aux(d,0)
  |(a,b)->(a,b)
  in 
   let x = ref (-(g.(i).(j)) in 
    for k=(i-1) to (i+1) do 
     for t=(j-1) to (j+1) do
      x:=!x+(g.(fst(aux(k,t))).(snd(aux(k,t))))
     done
    done;
!x;;

voila et on me repond tres poliment

Toplevel input:
> |(c,-1)->aux(c,p-1)
> ^^^^
Warning: this matching case is unused.
Toplevel input:
> |(d,p)->aux(d,0)
> ^^^
Warning: this matching case is unused.
Toplevel input:
> |(a,b)->(a,b)
> ^^^
Warning: this matching case is unused.
nb_voisins : int vect vect -> int -> int -> int -> int -> int = <fun>
#

et je sais pas ce qui ne va pas !!!

donc si vous pouviez me donner un petit coup de pouce ca n'est pas de refus

merci d'avance

[Cacophrene]

Bonsoir,

Ce code présente plusieurs problèmes :

• D'abord, tu ne sembles pas avoir compris ce qu'est le filtrage. Quand tu écris (n, b), il ne faut pas croire que cela signifie (x, b) when x = n, car ce n'est pas le cas. En d'autres termes, si tu veux vérifier qu'un élément de ton filtre est égal à une certaine valeur, il faut utiliser when. Écrire (n, b) stocke le premier élément du couple dans n, le second dans b, et c'est tout (aucune comparaison n'est effectuée).
• Ensuite, les conventions de nommage ne sont pas respectées. On ne donne généralement pas de règle toute faite et immuable, mais on déconseille fortement d'utiliser des noms à une seule lettre. Des noms convenablement choisis améliorent la lisibilité du code, la détection des anomalies et les évolutions ultérieures.
• Dans les boucles for, il y a des parenthèses inutiles qui alourdissent les notations et des expressions qui peuvent être simplifiées.

Cordialement,
Cacophrène

[darkontes]

a d'accord merci je vais regarder ca
mais c'est vrai que pour le filtrage je n'avais pas tres bien compris (d'un autre coté pour l'instant en classe on n'a fait que 6 h de TP ^^ donc je suis encore pas tres sur de ce que je fais )
voila je vais voir ca

[Cacophrene]

Re,

Une piste de code, qui ne corrige qu'une partie des problèmes évoqués ci-dessus :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let nb_voisins g n p i j =
  let rec aux = function
    | -1 -> aux (n - 1)
    | x when x = n -> aux 0
    | x -> (function
      | -1 -> aux x (p - 1)
      | y when y = p -> aux x 0
      | y -> (x, y)
  ) in
  let x = ref (-g.(i).(j)) in
  for k = i - 1 to i + 1 do
    for t = j - 1 to j + 1 do
      let a, b = aux k t in
      x := !x + g.(a).(b)
    done
  done;
  !x

Remarque : il y a au moins une autre manière de résoudre le problème de l'univers torique au jeu de la vie. Il s'agit d'un simple modulo. Je te laisse le soin de chercher un peu dans ce sens. Mais courage, c'est en bonne voie.

Cordialement,
Cacophrène

[darkontes]

bon je vais chercher vers le modulo quand meme parceque en attendant j'avais fait ca :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let nb_voisins grille n p i j =
 let rec aux = function 
  |(a,b) when (a=(-1))->aux(n-1,b)
  |(a,b) when (a=n)->aux(0,b)
  |(a,b) when (b=(-1))->aux(a,p-1)
  |(a,b) when (b=p)->aux(a,0)
  |(a,b)->(a,b)
  in 
   let x = ref (-(grille.(i).(j))) in
    for k=(i-1) to (i+1) do 
     for t=(j-1) to (j+1) do
      x:=!x+(grille.(fst(aux(k,t))).(snd(aux(k,t))))
     done
    done;
!x;;

mais c'est pas tres ... esthetique
en tout cas merci pour la piste parce que j'ai bien l'impression d'avoir compris : car exemple premier filtre a -1 je renvoie n-1 en fait je demande -1 modulo n et quand c'est n je demande de renvoyer 0 c'est a dire n modulo n ^^
en tout cas MERCI beaucoup

edition :
a oui je crois que ca y est

Code :

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

1
2
3
4
5
6
7
8
let nb_voisins grille n p i j =
let x = ref (-(grille.(i).(j))) in
    for k=(i-1) to (i+1) do 
     for t=(j-1) to (j+1) do
      x:=!x+(grille.(i mod n).(j mod p))
     done
    done;
!x;;

et c'est vraiment plus joli ^^

[Cacophrene]

Bonjour,

C'est effectivement plus rapide de l'écrire avec un modulo, mais attention quand même à ceci :

Code :

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

1
2
3
4
5
6
7
 
cacophrene(~)$ ocaml
        Objective Caml version 3.11.1
 
# -1 mod 10;;
- : int = -1
#

Il y a donc une petite chose à ajouter pour s'assurer que tu as bien des indices valides (c.-à-d. 0 <= i < longueur).

Cordialement,
Cacophrène

[adtunum]

Encore une remarque concernant l'indentation du code source.
En Caml on indente le code à 2 espaces.

Je te recommanderais de lire la documentation suivante (c'est bien c'est en français) concernant le formatage du code :
http://caml.inria.fr/resources/doc/g...elines.fr.html

[gasche]

Encore une remarque concernant l'indentation du code source.
En Caml on indente le code à 2 espaces.

Je ne suis pas d'accord. Chacun indente comme il veut, du moment que son code source reste cohérent (y compris quand plusieurs personnes y travaillent, qui doivent alors accorder leur indentation).

Je conseille personellement aux débutants d'utiliser 4 espaces, voire des tabulations (quand l'éditeur de texte n'indente pas automatiquement), car des espacements plus marqués rendent la lecture plus facile à un non-habitué.

[Cacophrene]

Bonjour,

Moi je suis longtemps resté à 4 espaces pour l'indentation, et même avant je mettais un espace avant les points-virgules. De gustibus et coloribus...

Cordialement,
Cacophrène

[darkontes]

ba merci, je vais essayer de faire attention les prochaines fois euh non je ne vais pas essayer : je vais le faire (heureusement que vous me le faites remarquer comme ca je ne prendrais pas l'habitude )

bon je vais lire la docu

clairs efficaces rapides sympathiques faisant des remarques constructives, ya pas moyen, je mets ce forum dans mes favoris ^^
vous etes supers merci beaucoup a tout le monde

[adtunum]

Bonsoir,

je suis d'accord avec vous que "les goûts et les couleurs, ça ne se discute pas"
cependant si on télécharge plusieurs projets depuis le hump on constate que la plus grande majorité des programmeurs ocaml ont adopté l'indentation à 2 espaces. Dans d'autres langages courants comme C, PHP, Perl, Python, il n'y a pas que je sache un tel ralliement autour d'une telle convention. Sauf peut-être avec Pear (le framework officiel de PHP) où on impose une indentation à 4 espaces obligatoirement.

En C ça ne me dérange pas de lire du code à 2, 3, 4 ou 8 espaces, en revanche pour lire du code OCaml il me faut réindenter à 2 espaces sinon j'ai beaucoup de mal à lire le code. Je ne sais pas pourquoi il y a un tel consensus pour l'indentation à 2 espaces en OCaml, c'est peut-être dut la structure de sa syntaxe.
Toujours est-il qu'étant donné ce consensus il paraît raisonnable de se rallier à l'usage courant.

Sinon au sujet des tabulations, pour moi c'est vraiment pire que tout !
Si on regarde le code des projets (pas uniquement en ocaml) écrits par plusieurs personnes, on constate que c'est le bazars pour 80% d'entre eux, avec un mélange de tabulation et d'espace. Et même parfois c'est l'horreur absolue : un mélange d'indentation tabulé et espacé avec les tab d'une largeur autre que 8 ce qui fout totalement en l'air l'indentation !
De plus souvent les commentaires de fin de ligne sont alignés avec une certaine largeur de la tabulation, et si on change cette largeur les commentaires ne seront plus alignés. Bref selon moi (et beaucoup d'autres) les tabulations sont à proscrire absolument !

L'auteur de Python a d'ailleurs déclaré que si c'était à refaire, il aurait fait en sorte que l'interpréteur Python refuse catégoriquement tout programme contenant des tabulations.

[InOCamlWeTrust]

Le consensus autour de l'indentation à 2 espaces n'en est pas vraiment un. OCaml dispose d'une fonction permettant de réécrire le code indenté avec 2 espaces, et manifestement, beaucoup de personnes l'utilisent (malheureusement !).

'\t' rules!