aggregate / 3 в swi-prolog

мне нужно сосчитать все X, что some_predicate(X) а таких действительно много X. Как лучше всего это сделать?

первая подсказка-найти все это, накопить в список и вернуть его длину.

countAllStuff( X ) :-
    findall( Y
           , permutation( [1,2,3,4,5,6,7,8,9,10], Y )
           , List
           ),
    length( List, X ).

(permutation/2 это только пример, показывающий, что есть много вариантов, и это плохой способ собрать все это)

очевидно, у меня есть переполнение стека.

?- countAllStuff( X ).
ERROR: Out of global stack

чем, я пытаюсь заменить findall в setof и ничего не меняется.

наконец-то я основал aggregate(кликабельные) предикаты и попытка использовать его.

?- aggregate(count, permutation([1,2,3,4], X), Y ).
X = [1, 2, 3, 4],
Y = 1 .

?- aggregate(count, [1,2,3,4], permutation([1,2,3,4], X), Y ).
X = [1, 2, 3, 4],
Y = 1 ;
X = [1, 2, 4, 3],
Y = 1 ;

все это неправильно, я думаю. Я предпочитаю получить что-то вроде

?- aggregate(count, permutation([1,2,3,4], X), Y ).
Y = 24 .

1) Что я делаю не так?

2) Как я могу объявить предикат, чтобы получить правильный ответ?

9
prolog swi-prolog

3 ответов

используйте экзистенциально квантифицированную переменную, как и в случае с setof:

?- aggregate(count, X^permutation([1,2,3,4], X), N).
N = 24.
9

в SWI-Prolog есть гораздо более эффективная версия, которая также позволяет избежать блокировки глобального магазина. Таким образом, просто используя nb_setval и nb_getval вы получаете по крайней мере 3 раза производительность (больше на многопоточности). Совсем недавно другой вопрос был о подсчете решений. Будучи основой агрегации, это очевидная точка остановки при изучении пролога. Чтобы оценить прирост эффективности, мы используем эти семантически эквивалентные вызовы monothread:

count_solutions(Goal, N) :-
assert(count_solutions_store(0)),
repeat,
(   call(Goal),
    retract(count_solutions_store(SoFar)),
    Updated is SoFar + 1,
    assert(count_solutions_store(Updated)),
    fail
;   retract(count_solutions_store(N))
), !.
:- dynamic count_solutions_store/1.

% no declaration required here
count_solutions_nb(Goal, N) :-
    nb_setval(count_solutions_store, 0),
    repeat,
    (   call(Goal),
        nb_getval(count_solutions_store, SoFar),
        Updated is SoFar + 1,
        nb_setval(count_solutions_store, Updated),
        fail
    ;   nb_getval(count_solutions_store, N)
    ), !.

parent(jane,dick).
parent(michael,dick).
parent(michael,asd).

numberofchildren(Parent, N) :-
    count_solutions_nb(parent(Parent, _), N).

many_solutions :-
    between(1, 500000, _).

time_iso :-
    time(count_solutions(many_solutions, N)),
    write(N), nl.

time_swi :-
    time(count_solutions_nb(many_solutions, N)),
    writeln(N).

в моей системе, я get

?- [count_sol].
% count_sol compiled 0,00 sec, 244 bytes
true.

?- time_iso.
tim% 1,000,006 inferences, 2,805 CPU in 2,805 seconds (100% CPU, 356510 Lips)
500000
true.

?- time_swi.
% 2,000,010 inferences, 0,768 CPU in 0,768 seconds (100% CPU, 2603693 Lips)
500000
true.
4

есть еще aggregate_all/3:

?- aggregate_all(count, permutation([1, 2, 3, 4], _), Total).
Total = 24.

однако, что касается времени выполнения и переполнения стека, похоже, он одинаково хорошо работает для вашего findall+length устранение:

?- N is 10^7, time(aggregate_all(count, between(1, N, _), Total)).
% 10,000,022 inferences, 5.075 CPU in 5.089 seconds (100% CPU, 1970306 Lips)
N = Total, Total = 10000000.

?- N is 10^7, time((findall(X, between(1, N, _), L), length(L, Total))).
% 10,000,013 inferences, 4.489 CPU in 4.501 seconds (100% CPU, 2227879 Lips)
N = 10000000,
L = [_G30000569, _G30000566, _G30000545|...],
Total = 10000000.

?- N is 10^8, aggregate_all(count, between(1, N, _), Total).
ERROR: Out of global stack

?- N is 10^8, findall(X, between(1, N, _), L), length(L, Total).
ERROR: Out of global stack

вы можете подсчитать решения, используя assert/retract, это довольно медленно, но избегает проблемы "из стека":

?- assert(counter(0)), N is 10^8, between(1, N, _),
   retract(counter(C)), C1 is C + 1, assert(counter(C1)), fail
   ; retract(counter(C)).
C = 100000000.
2