Lisp: compter un nombre d'élément d'une matrice

Bonjour, je débute en lisp et je rencontre le problème suivant: j'ai reussis à crée une matrice de taille n*m mais j'aimerai compter le nombre d'élément à NIL que contient cette matrice et je ne sait pas comment parcourir les lignes et colonne d'une matrice en lisp.

voilà mon code pour l'instant

Code:

---

1 2 3 4 5 6 7 8 9 10 11

(defun creer-grille(dim nb-coul) (setq flow (make-grille :dimensions dim :matrice (make-array dim :initial-element nil) :nb-couleurs nb-coul)))     (defun init-matrice(G n m) "Initialise tous les éléments de la matrice comme étant des structures zone" (defun init-case(G i j) (setf (aref (grille-matrice G) i j) (make-zone)))

---

cordialement

Salut !

S'il s'agit de matrices, il serait peut-être mieux de fournir M et N au lieu de DIM qui doit être une liste, si je ne me trompe pas ?

La façon naturelle de traverser un array c'est d'utiliser DOTIMES. Par exemple:

Code:

---

1 2 3 4 5 6

(defvar *a* #2A((1 2 NIL NIL 3) (3 4 NIL NIL NIL))) (let ((res 0)) (dotimes (i (array-dimension *a* 0) res) (dotimes (j (array-dimension *a* 1)) (when (aref *a* i j) (incf res))))) => 5

---

Le troisième argument de DOTIMES est optionnel. C'est ce qu'il doit renvoyer (NIL par défaut).

Je dois dire que ton code n'est pas fameux.

Dans CREER-GRILLE tu affectionnes la variable FLOW sans l'avoir déclarée; en plus, tu ne l'utilises jamais. En lisp, les affectations, elles aussi, renvoient des valeurs (normalment c'est ce que l'on a affecté), alors ta fonction renvoie la valeur renvoiée par SETQ. C'est bizarre.

Code:

---

1 2 3 4

(defun creer-grille(dim nb-coul) (make-grille :dimensions dim :matrice (make-array dim :initial-element nil) :nb-couleurs nb-coul))

---

Ça sera mieux.

Quant'à la deuxième fonction, c'est encore plus bizarre. Un DEFUN à l'intérieur d'un autre DEFUN, qu'est-ce que c'est ?

merci beaucoup c'est presque ce que je veux au détail près que j'ai une matrice n*m je me demande s'il ne vaut pas mieux passer par un defun ?

Code:

---

1 2 3 4 5 6

(defvar *a* #2A((1 2 NIL NIL 3) (3 4 NIL NIL NIL))) (let ((res 0)) (dotimes (i (array-dimension *a* 0) res) (dotimes (j (array-dimension *a* 1)) (when (aref *a* i j) (incf res))))) => 5

---

Ah, donc tu voulais créer une fonction auxiliaire ? À mon gout, ce n'est pas indispensable:

Code:

---

1 2 3 4 5 6

(defun init-grille-matrice(g) "Initialise tous les éléments de la matrice comme étant des structures zone" (let ((a (grille-matrice g))) (dotimes (i (array-dimension a 0)) (dotimes (j (array-dimension a 1)) (setf (aref a i j) (make-zone))))))

---

D'ailleurs, DEFUN sert à creer des fonctions globales, alors que des fonctions locales sont creées à l'aide de FLET ou LABELS.

Les arguments N et M dans la définition de INIT-MATRICE, ce sont les dimensions de la matrice ? Je pense qu'ils non sont nécessaires. D'une part, la matrice contient l'information de ses dimensions. D'autre part, si les dimensions d'une grille ne correspondent pas nécessairement à celles de sa matrice, il vaut mieux les garder dans la structure même.

par habitude je n'utilise que des defun ou defparameter. Oui n et m se sont les dimensions de la matrice. (de la grille de jeu plutôt)

Mais non, DEFUN vs FLET n'est pas question d'habitude. DEFUN déclares des fonctions globales. Regarde:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

CL-USER> (g 2) EVAL: undefined function G [Condition of type SYSTEM::SIMPLE-UNDEFINED-FUNCTION] ; Evaluation aborted on NIL CL-USER> ; Quit to level 1 CL-USER> ; Evaluation aborted on #<SYSTEM::SIMPLE-UNDEFINED-FUNCTION #x000333FC2110> CL-USER> (defun f (x) (defun g (x) (1+ x)) (g (g x))) F CL-USER> (g 2) EVAL: undefined function G [Condition of type SYSTEM::SIMPLE-UNDEFINED-FUNCTION] ; Evaluation aborted on NIL CL-USER> ; Quit to level 1 CL-USER> ; Evaluation aborted on #<SYSTEM::SIMPLE-UNDEFINED-FUNCTION #x000333FC14E8> CL-USER> (f 3) 5 CL-USER> (g 2) 3

---

D'abord je me convaincs que la fonction G n'existe pas. Ensuit je déclare une fonction F dont à l'intérieur je déclare une fonction G avec DEFUN. Cependent, la fonction G n'existe pas encore, car le corps de F n'a pas été évalué. Donc je calcule (F 3); cet appel de la fonction F a un effet secondaire, notamment il déclare une nouvelle fonction globale. Et voilà, enfin je peux utiliser G. Bizarre, eh? :)

La conclusion est que DEFUN n'a pas la même signification que DEFINE en Scheme et qu'il faut utiliser FLET et LABELS pour créer des fonctions locales. D'ailleurs, des fonctions locales sont pour la plupart utiles si elles sont clôtures (closures); autrement on peut tout simplement déclarer une fonction globale et ne pas exporter son symbole si elle n'est qu'auxiliaire.

oui merci beaucoup de l'exemple ;)