Create a conditional or selective rule using Clips [duplicate] - clips

Question

I hope you are doing very well? I am a beginner in regards to CLIPS. I have a graph of several nodes (start nodes (input) and of end nodes (output). I want to create a rule in the case where I have the number of input is equal to output, the rule must help me choose between several combinations (start and end nodes) the shortest path for each combination.
Another rule can be added with the same rule before, if I have the number of input is greater than the number of output or the opposite. After selecting between the combination it is also necessary to take into consideration the input or the output and to derive it towards the nearest point?
(deftemplate path
(slot start)
(slot end)
(multislot path)
(slot cost(type NUMBER)))
(deftemplate info
(slot start)
(slot end)
(multislot path)
(slot cost))
(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 varvar
?L<- (start ?start end ?end)
(path (start ?start)(end ?end)(path $?path)(cost ?cost))
=>
(retract ?L)
(printout t " PATH " ?start " to " ?end " by " ?path " with a cost of " ?cost crlf)
(assert (info (start ?start) (end ?end) (path $?path)
(cost ?cost)))
)
the combination result if i have 3 startnode and 2 endnode
how many node start 3
Enter nbr node start
start node name A
node start value 3
Enter nbr node start
start node name C
node start value 5
Enter nbr node start
start node name E
node start value 5
how many node end 2
Enter nbr node end
end node name B
node end value -5
Enter nbr node end
end node name I
node end value -5
PATH A to I by (A,a,m,I) with a cost of 3.5
PATH C to I by (C,c,d,n,m,I) with a cost of 9
PATH E to I by (E,n,m,I) with a cost of 4
PATH A to B by (A,a,b,B) with a cost of 7
PATH C to B by (C,c,b,B) with a cost of 5
PATH E to B by (E,n,k,g,b,B) with a cost of 5.8
and then As final result i hope to get
PATH A to I by (A,a,m,I) with a cost of 3.5 */ because it is the low cost between the 3 first combinaison */
PATH E to B by (E,n,k,g,b,B) with a cost of 5.8 */ because it is the low cost between the 3 second combinaison */
PATH C to B by (C,c,b,B) with a cost of 5 */ because it is the low cost between (C to B) and (C to I) */
I hope that it is clear ??
thank you for your help

Answer 1

Try combining rules info and varvar to the following:
(defrule varvar
(startnode ?start ?)
(endnode ?end ?)
(path (start ?start) (end ?end) (path $?path) (cost ?cost))
(not (and (endnode ?end2 ?)
(path (start ?start) (end ?end2) (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))))
The results you'll get are:
PATH A to I by (A,a,m,I) with a cost of 3.5
PATH E to I by (E,n,m,I) with a cost of 4
PATH C to B by (C,c,b,B) with a cost of 5
It's not clear why you're expecting path E to B to be selected since path E to I has a lower cost.