CLISP - profondeur limitée première recherche

Question

essayant d'écrire du code pour faire une profondeur limitée première recherche sur un problème donné et limite .. im très nouveau dans cette langue si cela est basiquement juste quelques réflexions .. Ne me intimider xD

(defstruct state 
    pos 
    vel 
    action 
    cost 
    track 
    other) 

(defstruct problem 
    initial-state 
    fn-nextStates 
    fn-isGoal 
    fn-h);heuristic funtion 

(defstruct node 
    parent 
    state) 

(defun limdepthfirstsearch (problem limit) 
    (return (recursiveldfs make-node(problem-initial-state) problem limit))) 

(defun recursiveldfs (node problem limit) 
    (if (problem-fn-isGoal (node-state node)) (solution(node))) 
    (if (= limit 0) ':corte) 

    (setf (cutoff_ocurred) nil) 

    (loop for each (possible-actions) in (problem-fn-nextstates(node-state node)) do 
    (setf (child) (nextState (node-state node) (possible-actions))) 
    (setf (result) (recursiveldfs child problem (- limit 1))) 
    (if (= result ':corte) (setf (cutoff_ocurred) t)) 
    (if (!= result nil) (return result)) 
) 
    (if (= cutoff_ocurred t) '(:corte)) 
    (if (= cutoff_ocurred nil) nil) 
) 

Answer 1

Je suis second @ Commentaire de BadZen, mais il semblerait que vous soyez assez nouveau sur le lisp commun, donc je vais juste donner quelques pointeurs ou commentaires à votre code. Tout d'abord, pensez à suivre une introduction à Lisp commun, par exemple: Practical common lisp pour commencer rapidement, ou mieux (bien que basé sur le schéma) the SICP lectures, pour une meilleure compréhension de Lisp.

Veuillez également soumettre un code qui compile au moins, ou poser une question sur les messages d'erreur que vous obtenez. Votre code ne compile pas. Et s'il vous plaît essayez d'utiliser un peu le style standard Common-Lisp, au moins séparer plusieurs mots dans les noms par "-". Votre code est difficile à lire.

à votre code:

1. En limdepthfirstsearch, return est inutile. En Common Lisp return est utilisé seulement pour retourner une valeur et la sortie d'un bloc nul nommé, par exemple une boucle, ou dolist, etc.

2. Dans la même fonction, make-node(problem-initial-state) a mauvaise syntaxe (ce n'est pas comment les fonctions lisp prennent des arguments), et de plus, make-node a besoin de deux arguments (parent et état). Ce que vous voulez probablement est: (recursiveldfs (make-node NIL (problem-initial-state problem)) problem limit) où NIL je suppose est le parent initial de problème (quoi que cela signifie dans vos structures). Si (problem-initial-state problem) est en fait une liste '(parent state) alors vous devez écrire (recursiveldfs (apply #'make-node (problem-initial-state problem)) problem limit)

3. Dans la définition de recursiveldfs, la déclaration (problem-fn-isGoal (node-state node) implique que (node-state node) renvoie une structure problem. Dans la même ligne, (solution(node)) est syntaxiquement faux, il n'y a pas de fonction appelée solution dans votre code, et node n'est pas une fonction non plus. Et un espace est manquant entre solution et (node). Je ne peux pas comprendre ce que l'on veut dire ici. Dans la définition de recursiveldfs, vous écrivez (setf (cutoff_ocurred) nil). Comme il n'y a pas de fonction appelée cutoff_ocurred, je présume que vous voulez dire (setf cutoff_ocurred nil), mais encore, il n'y a pas de variable appelée cutoff_ocurred. Que veut-on dire ici? Peut-être que vous devez commencer recursiveldfs avec un (let ((cutoff_ocurred nil)) ..) à la place?

4. Dans la boucle ci-dessous, déposez les parenthèses de (possible-actions) (deux occurrences). Une variable sur laquelle la boucle se produit est nécessaire ici.

5. (probem-fn-nextstates(node-state node)) manque un espace après problem-fn-nextstates, et encore, comme dans (3), cela implique que (node-state node) renvoie une structure problem. do va dans la ligne suivante (recherchez quelques guides de style Lisp commun). Après do, seule la première instruction appartient à do, le reste est syntaxiquement erroné. Si vous avez besoin de do plusieurs instructions dans une boucle, utilisez do (progn (...) (...) ... (...)).

6. child et result ne sont ni des fonctions définies ni des variables définies (voir 4).

7. Qu'est-ce que :corte?

S'il vous plaît réécrire votre code avec ces commentaires à l'esprit, et après avoir pris une introduction à Common Lisp (au moins deux ou trois chapitres du livre de gigamonkeys) et modifier votre question ou soumettre une nouvelle, avec le code qui compile, et avec des exemples, comme le suggère @BadZen. Je suggère également de taper vos structures en utilisant: type ou avec un commentaire.