繰り返し【CLIPS]

Question

(deftemplate path 
(slot start) 
(slot end) 
(multislot path) 
(slot cost(type NUMBER))) 

(deftemplate info 
(slot start) 
(slot end) 
(multislot path) 
(slot cost)) 


(deftemplate startend 
    (slot start) 
    (slot end)) 



(deffacts variable_table 

(path (start A)(end B)(path A,a,b,B)   (cost 7)) 
(path (start A)(end C)(path A,a,b,c,C)  (cost 10)) 
(path (start A)(end D)(path A,a,m,n,d,D)  (cost 8.5)) 
(path (start A)(end E)(path A,a,m,n,E)  (cost 5.5)) 
(path (start A)(end F)(path A,a,m,n,k,g,f,F) (cost 9.4)) 
(path (start A)(end CS) (path A,a,m,n,k,CS) (cost 6.7)) 
(path (start A)(end G)(path A,a,m,n,k,g,G) (cost 8)) 
(path (start A)(end H)(path A,a,m,n,d,e,H) (cost 10.3)) 
(path (start A)(end I)(path A,a,m,I)   (cost 3.5)) 

(path (start B)(end A) (path B,b,a,A)  (cost 7 )) 
(path (start B)(end C) (path B,b,c,C)  (cost 4)) 
(path (start B)(end D) (path B,b,c,d,D)  (cost 7)) 
(path (start B)(end E) (path B,b,g,k,n,E) (cost 5.8 )) 
(path (start B)(end F) (path B,b,g,f,F)  (cost 4.7)) 
(path (start B)(end CS)(path B,b,g,k,CS)  (cost 4.6)) 
(path (start B)(end G) (path NG2,b,g,G)  (cost 3.3)) 
(path (start B)(end H) (path NG2,b,g,f,e,H) (cost 6.5)) 
(path (start B)(end I) (path NG2,b,g,k,n,m,I)(cost 7.8)) 

(path (start C)(end A) (path C,c,b,a,A)  (cost 10)) 
(path (start C)(end B) (path C,c,b,B)  (cost 5)) 
(path (start C)(end D) (path C,c,d,D)  (cost 4)) 
(path (start C)(end E) (path C,c,d,n,E)  (cost 5.3)) 
(path (start C)(end F) (path C,c,d,e,f,F) (cost 7.6)) 
(path (start C)(end CS)(path C,c,b,g,k,CS) (cost 7.6)) 
(path (start C)(end G) (path C,c,b,g,G)  (cost 6.3)) 
(path (start C)(end H) (path C,c,d,e,H)  (cost 5.8)) 
(path (start C)(end I) (path C,c,d,n,m,I) (cost 9)) 

(path (start D)(end A) (path D,d,n,m,a,A) (cost 8.5)) 
(path (start D)(end B) (path D,d,c,b,B)  (cost 7)) 
(path (start D)(end C) (path D,d,c,C)  (cost 4)) 
(path (start D)(end E) (path D,d,n,E)  (cost 5)) 
(path (start D)(end F) (path D,d,e,f,F)  (cost 5.6)) 
(path (start D)(end CS)(path D,d,n,k,CS)  (cost 6.2)) 
(path (start D)(end G) (path D,d,e,f,g,G) (cost 6)) 
(path (start D)(end H) (path D,d,e,H)  (cost 3.8)) 
(path (start D)(end I) (path D,d,n,m,I)  (cost 7)) 

(path (start E)(end A) (path E,n,m,a,A)  (cost 5.5)) 
(path (start E)(end B) (path E,n,k,g,b,B) (cost 5.8)) 
(path (start E)(end C) (path E,n,d,c,C)  (cost 7)) 
(path (start E)(end D) (path E,n,d,D)  (cost 5)) 
(path (start E)(end F) (path E,n,k,g,f,F) (cost 5.9)) 
(path (start E)(end CS)(path E,n,k,CS)  (cost 3.2)) 
(path (start E)(end G) (path E,n,k,g,G)  (cost 4.5)) 
(path (start E)(end H) (path E,n,d,e,H)  (cost 6.8)) 
(path (start E)(end I) (path E,n,m,I)  (cost 4)) 

(path (start F)(end A) (path F,f,g,k,n,m,a,A)(cost 9.4)) 
(path (start F)(end B) (path F,f,g,b,B)  (cost 4.7)) 
(path (start F)(end C) (path F,f,e,d,c,C) (cost 7.6)) 
(path (start F)(end D) (path F,f,e,d,D)  (cost 5.6)) 
(path (start F)(end E) (path F,f,g,k,n,E) (cost 5.9)) 
(path (start F)(end CS)(path F,f,g,k,CS)  (cost 4.7)) 
(path (start F)(end G) (path F,f,g,G)  (cost 3.4)) 
(path (start F)(end H) (path F,f,e,H)  (cost 3.8)) 
(path (start F)(end I) (path F,f,g,k,n,m,I) (cost 7.9)) 


(path (start CS)(end A) (path CS,k,n,m,a,A) (cost 6.7)) 
(path (start CS)(end B) (path CS,k,g,b,B) (cost 4.6)) 
(path (start CS)(end C) (path CS,K,g,b,c,C) (cost 7.6)) 
(path (start CS)(end D) (path CS,k,n,d,D) (cost 6.2)) 
(path (start CS)(end E) (path CS,K,N,E)  (cost 3.2)) 
(path (start CS)(end F) (path CS,k,g,f,F) (cost 4.7)) 
(path (start CS)(end G) (path CS,k,g,G)  (cost 3.3)) 
(path (start CS)(end H) (path CS,k,g,f,e,H) (cost 6.5)) 
(path (start CS)(end I)(path CS,k,n,m,I)  (cost 5.2)) 

(path (start G)(end A) (path G,g,k,n,m,a,A) (cost  8)) 
(path (start G)(end B) (path G,g,b,B)  (cost 3.3)) 
(path (start G)(end C) (path G,g,b,c,C)  (cost 6.3)) 
(path (start G)(end D) (path G,g,f,e,d,D) (cost 6)) 
(path (start G)(end E) (path G,g,k,n,E)  (cost 4.5)) 
(path (start G)(end F) (path G,g,f,F)  (cost 3.4)) 
(path (start G)(end CS)(path G,g,k,CS)  (cost 3.3)) 
(path (start G)(end H) (path G,g,f,e,H)  (cost 5.2)) 
(path (start G)(end I) (path G,g,k,n,m,I) (cost 6.5)) 

(path (start H)(end A) (path H,e,d,n,m,a,A) (cost 10.3)) 
(path (start H)(end B) (path H,e,f,g,B)  (cost 6.5)) 
(path (start H)(end C) (path H,e,d,C)  (cost 3.8)) 
(path (start H)(end D) (path H,e,d,c,D)  (cost 5.8)) 
(path (start H)(end E) (path H,e,d,n,E)  (cost 6.8)) 
(path (start H)(end F) (path H,e,f,F)  (cost 3.8)) 
(path (start H)(end CS)(path H,e,f,g,k,CS) (cost 6.5)) 
(path (start H)(end H) (path H,e,f,g,H)  (cost 5.2)) 
(path (start H)(end I) (path H,e,d,n,m,I) (cost 8.8)) 

(path (start I)(end A) (path I,m,a,A)  (cost 3.5)) 
(path (start I)(end B) (path I,m,n,k,g,b,B) (cost 7.8)) 
(path (start I)(end C) (path I,m,n,d,c,C) (cost 9)) 
(path (start I)(end D) (path I,m,n,d,D)  (cost 7)) 
(path (start I)(end E) (path I,m,n,E)  (cost 4)) 
(path (start I)(end F) (path I,m,n,k,g,f,F) (cost 7.9)) 
(path (start I)(end CS)(path I,m,m,k,CS)  (cost 5.2)) 
(path (start I)(end G) (path I,m,n,k,g,G) (cost 6.5)) 
(path (start I)(end H) (path I,m,n,d,e,I) (cost 8.8))) 

(defrule lancesaisiepoint 
?f1 <- (debut node) 
=> 
    (retract ?f1) 
    (printout t "how many node start") 
    (bind ?x (read)) 
    (assert (startnode ?x)) 
) 

(defrule saisiepoint 
?f <- (startnode ?a) 
    (test (> ?a 0)) 
=> 
(printout t " Enter nbr node start" crlf) 
(printout t "start node name ") 
(bind ?start (read)) 
(printout t "node start value ") 
(bind ?y1 (read)) 
(assert (startnode ?start ?y1)) 
(retract ?f) 
(assert (startnode (- ?a 1))) 
) 

(defrule lancesaisiemoins 
?f1 <- (startnode 0) 
=> 
(retract ?f1) 
(printout t "how many node end ") 
(bind ?x (read)) 
(assert (endnode ?x)) 
) 

(defrule saisiemoins 
?f <- (endnode ?a) 
(test (> ?a 0)) 
=> 
(printout t "Enter nbr node end" crlf) 
(printout t "end node name ") 
(bind ?end (read)) 
(printout t "node end value ") 
(bind ?y2 (read)) 
(assert (endnode ?end ?y2)) 
(retract ?f) 
(assert (endnode (- ?a 1)))) 


(defrule supprnbrpoint ;compter 
?x<- (startnode 0) 
=> 
    (retract ?x) 
    ) 

(defrule supprnbrmoins 
?x<- (endnode 0) 
=> 
    (retract ?x) 
    ) 

(defrule info 

?M <- (startnode ?start ?y1) 
?K <- (endnode ?end ?y2) 
    => 
(assert (start ?start end ?end))) 


(defrule var 

?e1 <-(startnode ?start ?) 
?f1 <-(endnode ?end ?) 
(path (start ?start) (end ?end) (path $?path) (cost ?cost)) 

(not (and (startnode ?start$? ?) 
     (path (start ?start$?) (end ?end) (cost ?cost?&:(< ?cost? ?cost))))) 
    => 


    (printout t " PATH " ?start " to " ?end " by " ?path " with a cost of " ?cost crlf) 
    (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost)))) 

(defrule var1 

    ?e2 <-(startnode ?start ?) 
    ?f2 <-(endnode ?end ?) 
    (path (start ?start) (end ?end) (path $?path) (cost ?cost)) 

(not (and (endnode ?end$? ?) 
(path (start ?start) (end ?end$?) (cost ?cost2&: 
(< ?cost2 ?cost))))) 
    => 

    (printout t " PATH " ?start " to " ?end " by " ?path " with a cost of " ?cost crlf) 
    (assert (info (start ?start) (end ?end) (path $?path) (cost 
?cost)))) 

this pict show the result when we have the number of start node greedy than the end node

this pict show the result if i have the number of start node equal to the number of end node

ので、私は3の優れた任意の数の同じ3結果combinaisonを有します。 私が期待しているのは、コストの最も低いコーラスの入力数（nmr開始ノードと終了ノードの間）のすべての組み合わせを持つことです。 私は引っ込めを試みたが、それは別の結果を与えるかもしれない私はコードにそれを置くかもしれない。

と私は別のソリューション、たとえばクラスや関数を使用する場合はどうですか？しかし、私はこの分野ではまだ新しいので、私は何ができるか知りません、あなたの助けを大変ありがとうございます。

Answer 1

最短パスを検出するルールが複数ある場合は、各ルールにパターンを追加して、他のルールで検出されたパスを除外する必要があります。

(defrule var 
    ?e1 <- (startnode ?start ?) 
    ?f1 <- (endnode ?end ?) 
    (path (start ?start) (end ?end) (path $?path) (cost ?cost)) 
    (not (and (startnode ?start$? ?) 
      (path (start ?start$?) (end ?end) (cost ?cost?&:(< ?cost? ?cost))))) 
    (not (info (start ?start) (end ?end))) 
    => 
    (printout t " PATH " ?start " to " ?end " by " ?path " with a cost of " ?cost crlf) 
    (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost)))) 

(defrule var1 
    ?e2 <- (startnode ?start ?) 
    ?f2 <- (endnode ?end ?) 
    (path (start ?start) (end ?end) (path $?path) (cost ?cost)) 
    (not (and (endnode ?end$? ?) 
      (path (start ?start) (end ?end$?) (cost ?cost2&:(< ?cost2 ?cost))))) 
    (not (info (start ?start) (end ?end))) 
    => 
    (printout t " PATH " ?start " to " ?end " by " ?path " with a cost of " ?cost crlf) 
    (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost))))