Discussion :

[lenneth666]

bonjour

j'ai un prédicat qui est codé de la façon suivante :

Code :

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

1
2
3
4
eleve("marie").
eleve("maria").
eleve("louis").
eleve("damien").

Dans un autre prédicat qui s'appelle nb, je voudrais savoir combien de variables X vérifie le prédicat elève. Comment pourrais-je faire ?

[pcaboche]

Tu peux faire:

Code :

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

1
2
3
nbSol(Nb) :-
  findall(X, predicat(X), L),
  length(L, Nb).

Mais le problème, c'est que ça créé une liste des solutions (ce qui utilise potentiellement beaucoup de mémoire) juste pour en connaître la taille.

Il y a d'autres manières de faire plus ou moins capilo-tractées...

[Trap D]

Et une version capilotractée, une :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
:- dynamic(nombre/1).
 
eleve(marie).
eleve(maria).
eleve(louis).
eleve(damien).
eleve(frederic).
 
test(Z) :-
    retractall(nombre(_)),
    assert(nombre(0)),
    forall(eleve(_), 
           (nombre(X), retract(nombre(X)), X1 is X+1, assert(nombre(X1)))),
    nombre(Z).

[pcaboche]

Et une version capilotractée, une :

C'est exactement à celle-là que je pensais, mais sur le coup de midi "il commençait à faire faim" comme on dit, donc j'ai pas voulu passer trop de temps là-dessus.

[Trap D]

Deux questions à ce propos :
Comment faire pour passer en argument le prédicat dont on désire connaître le nombre d'éléments le vérifiant (il n' y a pas un mot pour ça ?)
style :

Code :

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

1
2
3
4
5
6
nombre_d_occurences(Pre, N) :-
    retractall(nombre(_)),
    assert(nombre(0)),
    forall(Pred(_), 
           (nombre(X), retract(nombre(X)), X1 is X+1, assert(nombre(X1)))),
    nombre(Z).

Autre question, dans cette clause, X prend successivement les valeurs 0, 1 2 3 et 4, alors que d'après ce que j'ai compris de l'unification ce n'est pas possible que X puisse prendre plusieurs valeurs successivement.

[pcaboche]

Comment faire pour passer en argument le prédicat dont on désire connaître le nombre d'éléments le vérifiant ?

Comme une variable:

Code :

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

1
2
nb_occur(Predicat, Nb) :-
  ...

et après, on peut appeler le prédicat avec call/_ (il en plusieurs prédicats call/_):

Code :

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

   call(Predicat, X),

... voire directement:

Code :

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

   Predicat(X),

mais c'est moins souple...

(il n' y a pas un mot pour ça ?)

Un "callable", je crois.

Autre question, dans cette clause, X prend successivement les valeurs 0, 1 2 3 et 4, alors que d'après ce que j'ai compris de l'unification ce n'est pas possible que X puisse prendre plusieurs valeurs successivement.

Une variable n'est pas censée changer de valeur en cours d'exécution... sauf dans le cas d'un backtrack (heureusement d'ailleurs !).

Dans le cas d'un forall/findall/setof/bagof, il se produit plusieurs backtracks et donc on se retrouve avec plusieurs fois la variable X non unifiée. C'est par l'appel de nombre(X) que X se retrouve unifié à nouveau.

[Trap D]

Merci

Code :

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

1
2
3
4
5
test(Predicat, Z) :-
	retractall(nombre(_)),
	assert(nombre(0)),
    forall(call(Predicat, _), (nombre(X), retract(nombre(X)), X1 is X+1, assert(nombre(X1)))),
    nombre(Z).

Ça ne fonctionne pas en appelant seulement Predicat(X), il faut absolument le call.

[Trap D]

J'ai un peu amélioré le prédicat de comptage pour le rendre plus général, pour qu'il puisse fonctionner avec des prédicats d'arité quelconque :

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
19
20
21
22
23
24
25
26
27
:- dynamic(nombre/1).
 
eleve(marie).
eleve(maria).
eleve(louis).
eleve(damien).
eleve(frederic).
famille(marie, louis).
famille(damien, frederic).
 
nb_callable(Predicat, Z) :-
    retractall(nombre(_)),
    assert(nombre(0)),
    Pred =.. Predicat,
    forall(call(Pred), (nombre(X), 
                           retract(nombre(X)), 
                           X1 is X+1, 
                           assert(nombre(X1)))),
    nombre(Z).
 
essai :-
	eleve(_) =.. Pred,
	nb_callable(Pred, Z),
	write('Nombre de faits pour eleve : '), writeln(Z),
	famille(_,_) =.. Pred1,
	nb_callable(Pred1, Z1),
	write('Nombre de faits pour famille : '), writeln(Z1).

Sortie :

?- essai.
Nombre de faits pour eleve : 5
Nombre de faits pour famille : 2