Discussion :

[Alpha573]

Bonjour,
Alors j'ai des prédicats,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
predA(1)
predA(2)
predA(3)
predA(4)
predA(5)
predA(6)
 
predB(1)
predB(2)
predB(3)
predB(4)
predB(5)
predB(6)

Ensuite j'ai mes prédicats qui me permettent de placer les bornes min et max dans une liste :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
bornes(R) :-                                                            
   findall(X, predA(X), L),                                                  
   last(L, Max),                                                                
   nth0(0, L, Min),                                                             
   R=[Min,Max].
 
bornes(R) :-                                                            
   findall(X, predB(X), L),                                                  
   last(L, Max),                                                                
   nth0(0, L, Min),                                                             
   R=[Min,Max].

Donc j'obtiens 2 listes qui contiennent les bornes.
En fait ce que je voudrais faire, c'est pourvoir générer toutes les combinaisons possibles des 2 listes.

Merci !

[Trap D]

Tu peux faire un peu plus rapidement les extractions des extrèmes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
bornes(Pred, R) :-
   P =.. [Pred, X],
   bagof(X, call(P), L),
   sort(L, [Min| Rest]),
   last(Rest, Max),
   R=[Min,Max].
 
 
bornes :-
	bornes(predA, RA),
	bornes(predB, RB),
	writeln(RA),
	writeln(RB).

Maintenant, qu'appelles-tu exactement faire toutes les combinaisons possibles des deux listes ? tu peux donner des exemples ?

[Alpha573]

Merci pour l'astuce (je début juste en Prolog).
Ensuite, pour le combinaisons ce que j'entends c'est (11) (12) (13) ... (16) puis
(21) (22) (23) ... (26).
Ça aurait été plus claire avec des lettres.

Merci encore !

[Trap D]

OK.
Tu veux lier chaque élément de L1 à chaque élément de L2.
Tu a donc deux traitements successifs sur des listes .
Un premier traitement pour sélectionner un élément de L1, puis une fois que cet élément est sélectionné tu vas faire un deuxième traitement pour sélectionner un élément de L2 et le lier à l'élément sélectionné de L1.
TU me suis ?

La fonction toute indiquée en SWI-Prolog pour traiter les listes est maplist qui a un gout fonctionnel puisqu'elle permet d'appliquer un prédicat sur tous les éléments d'une liste.

Ton code commencera ainsi

Code :

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

1
2
combi_liste(L1, L2, R) :-
  maplist(traitement(L2), L1, R).

le maplist permet d'appliquer traitement(L2) a chaque élément de L1

Ton prédicat traitement s'ecrit :

Code :

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

traitement(Liste, Element, Resultat) :-

Tu as donc une liste et un élément.
Inspire toi de ce que j'ai dit pour obtenir ce que tu veux.

[Alpha573]

Merci beaucoup pour votre aide.
J'ai pas le temps de tester pour l'instant.
Je vous fait un retour dès que j'ai le temps.

[tbertrand]

en swi-prolog:

combiL1L2([E1, E2], L1, L2) :- select(E1, L1, _), select(E2, L2, _).


renvera toutes les combinaisons, même pour des listes L1 et L2 de longueur différentes.

combiL1L2(L, [1,2,3,4,5,6],[a,b,c]) fournira
L=[1,a],
L=[1,b],
L=[1,c],
L=[2,a],
...
L=[6,c]

[Trap D]

tbertrand >> Tu as parfaitement raison !!!
Je pense parfois trop en terme fonctionnel.
Simplement au lieu de select, un simple member suffit.

[junkie1986]

Tu peux faire un peu plus rapidement les extractions des extrèmes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
bornes(Pred, R) :-
   P =.. [Pred, X],
   bagof(X, call(P), L),
   sort(L, [Min| Rest]),
   last(Rest, Max),
   R=[Min,Max].
 
 
bornes :-
	bornes(predA, RA),
	bornes(predB, RB),
	writeln(RA),
	writeln(RB).

Maintenant, qu'appelles-tu exactement faire toutes les combinaisons possibles des deux listes ? tu peux donner des exemples ?

Bonjour Trap D,

Je ne sais pas si c 'est à cause d'Amzi ou de moi mais j'ai du mal avec votre code.

J'ai 3 prédicats au départ :

Code :

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

1
2
3
predicat(5).
predicat(3).
predicat(2).

Puis j'ai ce petit programme qui demande à l'utilisateur de rentrer une valeur et enfin j' appel votre programme, le but final étant de comparer la valeur rentrée avec la valeur MAX du prédicat pred :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 a :- write('Entrez une valeur'),read(A),bornes(Pred, R, A).
 
   bornes(Pred, R, A) :-
   P =[Pred, X],
   bagof(X, call(P), L),
   sort(L, [Min| Rest]),
   last(Rest, Max),
   R=[Min,Max],proc(A,Max).
 
 
proc(A,Max):-A<Max,!,write('MAX > Valeur rentrée').
proc(_,_):-write('MAX < Valeur rentrée').

Les 2 clauses proc fonctionnent sur Amzi mais pas sur SWI prolog, je recois cette erreur :
Syntax error: Unexpected end of clause

merci

[Trap D]

Bonjour
Je viens de tester le prog, tu as oublié les .. après le = dans P = [Pred, X], il faut écrire P =.. [Pred, X].
Tout fonctionne alors bien dans ton code en SWI-Prolog.

[junkie1986]

Bonjour
Je viens de tester le prog, tu as oublié les .. après le = dans P = [Pred, X], il faut écrire P =.. [Pred, X].
Tout fonctionne alors bien dans ton code en SWI-Prolog.

Bonjour,

Je viens de passer 2 h sur ce code et honnêtement des que je trouve une solution à un problème un nouveau problème survient.
Je voudrais simplement à partir de 2 prédicats différents,enregistrer leurs valeurs Max dans 2 fichier différents nommées user_1 et user_2, et comparer ces valeurs entre elles. Je remercie TrapD pour le code qu'il a fournit précédemment mais aller savoir pourquoi le prédicat last(Rest, Max) ne fonctionne pas sous Amzi!

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
predA(1).
predA(2).
predA(3).
predA(4).
predA(5).
predA(6).
 
predB(2).
predB(5).
predC(6).
predC(8).
 
 
bornes(Pred) :-
   P =..[Pred, X],
   setof(X, call(P), L),
   sort(L, [Min| Rest]),
   last_item(L, Max).
 
last_item([], _) :-
   !,
   fail.
last_item([X], X) :-
   !.
last_item([_|Z], X) :-
   last_item(Z, X),!,
   assertz(user_1(X)),
   tell('user_1.pro'),
   listing(user_1),
   told,!.
 
 
 
max(Pred_1,Pred_2) :- 
        consult('user_1.pro'),
        consult('user_2.pro'), 
	P =..[Pred_1, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_1(Max)),
        P =..[Pred_2, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_2(Max)),
        tell('user.pro'),
        listing(user_1),
        listing(user_2),
        told,u.
 
 
u :- 
	user_1(X),
	user_2(Y),
	proc(X,Y).
 
proc(X,Y):-X>Y,!,write('user_1 Max'). % Si Valeur max de user_1 > user_2
proc(_,_):-write('user_2 Max'). % Si Val max de user_2 < user_1

Dans la clause last_item, je trouve et j’enregistre la valeur Max de mon prédicatA que j'enrengistre sous user_1.pro, je dois par la suite réitéré avec le prédicatB et ne pas oublier de remplacer partout ou se trouve user_1 par user_2.

Avec le prédicat max je voudrais consulter simultanément mes 2 fichiers et enrengistrer dans le fichier user.pro les valeurs Max de user_1 et de user_2. En effet, je ne sais pas pourquoi j'ai plusieurs prédicats qui contiennent la valeur Max.

Puis pour finir avec la clause u comparer la valeur Max des 2 prédicats.

Merci

[Trap D]

Bonjour

Je viens de regarder le code. Il présente quelques problèmes :

Code :

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

1
2
3
4
5
bornes(Pred) :-
   P =..[Pred, X],
   setof(X, call(P), L),
   sort(L, [Min| Rest]),
   last_item(L, Max).

Sous SWI-Prolog, j'ai un warning à la compilation : Min, Rest, Max sont des singletons ce qui signifient qu'ils ne sont utilisés qu'une fois et donc en fait ils sont définis pour rien puisque jamais réutilisés (les variables sont locales aux prédicats) !

Ce code présente aussi un problème :

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
max(Pred_1,Pred_2) :-
        consult('user_1.pro'),
        consult('user_2.pro'),
	P =..[Pred_1, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_1(Max)),
        P =..[Pred_2, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_2(Max)),
        tell('user.pro'),
        listing(user_1),
        listing(user_2),
        told,u.

Tu utilises deux fois les mêmes noms de variables ce qui sous-entend que ce sont les mêmes (par exemple pour P et L) , ce qui ne peut pas fonctionner.

Pour ce qui est de last tu peux le définir ainsi

Code :

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

1
2
last(L, Last) :-
  reverse(L, [Last | _]).

Last est le premier élément de la liste inversée !

Apparemment, user_1 et user_2 sont des faits dynamiques, en SWI-Prolog, il faut les déclarer par :- dynamic user_1/1, user_2/1. c'est "plus propre".

[junkie1986]

Bonjour

Je viens de regarder le code. Il présente quelques problèmes :

Code :

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

1
2
3
4
5
bornes(Pred) :-
   P =..[Pred, X],
   setof(X, call(P), L),
   sort(L, [Min| Rest]),
   last_item(L, Max).

Sous SWI-Prolog, j'ai un warning à la compilation : Min, Rest, Max sont des singletons ce qui signifient qu'ils ne sont utilisés qu'une fois et donc en fait ils sont définis pour rien puisque jamais réutilisés (les variables sont locales aux prédicats) !

Ce code présente aussi un problème :

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
max(Pred_1,Pred_2) :-
        consult('user_1.pro'),
        consult('user_2.pro'),
	P =..[Pred_1, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_1(Max)),
        P =..[Pred_2, X],
	setof(X, call(P), L),
	sort(L,[Max|_]),
   	assertz(user_2(Max)),
        tell('user.pro'),
        listing(user_1),
        listing(user_2),
        told,u.

Tu utilises deux fois les mêmes noms de variables ce qui sous-entend que ce sont les mêmes (par exemple pour P et L) , ce qui ne peut pas fonctionner.

Pour ce qui est de last tu peux le définir ainsi

Code :

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

1
2
last(L, Last) :-
  reverse(L, [Last | _]).

Last est le premier élément de la liste inversée !

Apparemment, user_1 et user_2 sont des faits dynamiques, en SWI-Prolog, il faut les déclarer par :- dynamic user_1/1, user_2/1. c'est "plus propre".

Bonjour,

Merci TrapD pour l'explication fournie, j'ai finalement résolu mon problème d'un manière "plus simple" mais "mois jolie" faute de temps.
J'ai simplement dupliqué mes clauses qui me permettaient d'obtenir la valeur Max d'un prédicat. C'est à dire que j'utilise une clause qui se nomme user_1(predA) et une autre user_2(predB). Puis, j’en appelle une dernière qui consult les fichiers dans lesquels les val Max de predA et predB sont enregistrés, les compare et enregistre dans un fichier soit "Valeur de predA est Max" soit "Valeur de predB est Max".