21

在 CLP(FD) 中,我们经常需要声明:“这是(有时:严格)升序/降序的整数和有限域变量的列表。”

是否有任何 CLP(FD) 系统为此任务提供通用(可参数化)内置约束?

SWI-Prolog 提供了一个名为 的约束chain/2,这与我正在寻找的类似。但是,这个名称有点过于具体,无法包含约束可以描述的所有关系(例如:#<不是偏序但在 中是可接受的chain/2,导致序列 - 被视为一组整数 - 不再算作中定义的链数学顺序理论)。因此,该名称并未完全描述约束实际实现的内容。

请给出关于通常二进制 CLP(FD) 约束的最一般定义——或至少包含 、 和 的合适子集#<——#>包括#=<根据#>=约束定义的代数结构的专有名称。施加的条件是约束描述了在文献中具有专有名称的实际数学结构。

首先,考虑使用 SICStus Prolog 或 SWI:

:- use_module(library(clpfd)).

connex(Relation_2, List) :-
    connex_relation(Relation_2),
    connex_(List, Relation_2).

connex_relation(#=).
connex_relation(#<).
connex_relation(#=<).
connex_relation(#>).
connex_relation(#>=).

connex_([], _).
connex_([L|Ls], Relation_2) :-
    foldl(adjacent(Relation_2), Ls, L, _).

adjacent(Relation_2, X, Prev, X) :- call(Relation_2, Prev, X).

示例案例:

?- connex(#<, [A,B,C]).
A#=<B+-1,
B#=<C+-1.

?- connex(#=, [A,B,C]).
A = B, B = C,
C in inf..sup.

?- maplist(connex(#<), [[A,B],[C,D]]).
A#=<B+-1,
C#=<D+-1.

请注意,甚至可以允许#\=,因为该关系仍将描述数学顺序理论中已知的连接。因此,就通常的二进制 CLP(FD) 约束而言,上面的代码并不是最通用的。

4

3 回答 3

9

Hoogle 不是很有用,但Hayoo 是!

foldcmpl

所以这是列表的一种特殊折叠形式,但它不应用length list次数,而是应用次数少。

isSortedBy

它的名称并不完全通用,但在其签名中。也许坚持使用最通用的名称并没有太大帮助。否则我们只是到处都是实体?

定义如下:

如果谓词对列表中的所有相邻元素对返回 true,则 isSortedBy 函数返回 True。

也许:all_adjacent_pairs(R_2, Xs)adjacent_pair在有一个具有某种修饰符的循环构造之后,这听起来有点。

于 2014-11-25T15:01:23.620 回答
5

这是受到我曾经实现的功能性高阶习语工具箱的启发。那时我发现角落案例令人痛苦,我今天仍然这样做:)另外,找到好名字总是一个问题......

考虑元谓词mapadj/4

mapadj(Relation_4,As,Bs,Cs) :-
   list_list_list_mapadj(As,Bs,Cs,Relation_4).

list_list_list_mapadj([],[],[],_).
list_list_list_mapadj([A|As],Bs,Cs,Relation_4) :-
   list_prev_list_list_mapadj(As,A,Bs,Cs,Relation_4).

list_prev_list_list_mapadj([],_,[],[],_).
list_prev_list_list_mapadj([A1|As],A0,[B|Bs],[C|Cs],Relation_4) :-
   call(Relation_4,A0,A1,B,C),
   list_prev_list_list_mapadj(As,A1,Bs,Cs,Relation_4).

样品用途:

z_z_sum_product(X,Y,Sum,Product) :-
   Sum     #= X + Y,
   Product #= X * Y.

:- mapadj(z_z_sum_product,[],       [],     []).
:- mapadj(z_z_sum_product,[1],      [],     []).

:- mapadj(z_z_sum_product,[1,2],    [3],    [2]).
:- mapadj(z_z_sum_product,[1,2,3],  [3,5],  [2,6]).
:- mapadj(z_z_sum_product,[1,2,3,4],[3,5,7],[2,6,12]).

我知道角落案例中的裂痕As = []As = [_]但我仍然觉得这与“所有相邻列表项”一样接近。

此外,所有这些都可以轻松扩展:

  • 下降到mapadj/2(类似于chain/2,除了单例列表的类型检查)
  • 侧身,带有额外的状态参数,到foldadjl/nscanadjl/n

关于名称:IMO l/r后缀是必需的fold/ scan,但不是map.


编辑 2015-04-26

这是前面提到的foldadjl/4

foldadjl(Relation_4,Xs) -->
   list_foldadjl(Xs,Relation_4).

list_foldadjl([],_) -->
   [].
list_foldadjl([X|Xs],Relation_4) -->
   list_prev_foldadjl(Xs,X,Relation_4).

list_prev_foldadjl([],_,_) -->
   [].
list_prev_foldadjl([X1|Xs],X0,Relation_4) -->
   call(Relation_4,X0,X1),
   list_prev_foldadjl(Xs,X1,Relation_4).

编辑 2015-04-27

这里是 meta-predicate splitlistIfAdj/3,基于 if_/3它是在先前关于具体化的答案中提出的

split_if_adj(P_3,As,Bss) :- splitlistIfAdj(P_3,As,Bss).

splitlistIfAdj(P_3,As,Bss) :- 
   list_split_(As,Bss,P_3).

list_split_([],[],_).
list_split_([X0|Xs],     [Cs|Bss],P_3) :-
   list_prev_split_(Xs,X0,Cs,Bss, P_3).

list_prev_split_([],     X, [X],[],_).
list_prev_split_([X1|Xs],X0,[X0|Cs],Bss,P_3) :-
   if_(call(P_3,X0,X1), 
       (Cs = [],  Bss = [Cs0|Bss0]),
       (Cs = Cs0, Bss = Bss0)),
   list_prev_split_(Xs,X1,Cs0,Bss0,P_3).

为了在使用中显示它,让我们定义与翻转真值dif/3完全相同的方式:(=)/3

dif(X, Y, R) :- X == Y,    !, R = false.
dif(X, Y, R) :- ?=(X, Y),  !, R = true. % syntactically different
dif(X, Y, R) :- X \= Y,    !, R = true. % semantically different
dif(X, Y, R) :- R == false, !, X = Y.
dif(X, X, false).
dif(X, Y, true) :-
   dif(X, Y).

现在我们一起使用它们:

?- splitlistIfAdj(dif,[1,2,2,3,3,3,4,4,4,4],Pss).
Pss = [[1],[2,2],[3,3,3],[4,4,4,4]].      % succeeds deterministically

如果我们概括一些列表项怎么办?我们是否得到了具有正确未决目标的多个答案?

首先,一个小例子:

?- splitlistIfAdj(dif,[1,X,2],Pss).
X = 1,             Pss = [[1,1],[2]]  ;
X = 2,             Pss = [[1],[2,2]]  ;
dif(X,1),dif(X,2), Pss = [[1],[X],[2]].

一个更大的例子,涉及两个变量XY

?- splitlistIfAdj(dif,[1,2,2,X,3,3,Y,4,4,4],Pss).
X = 2,             Y = 3,             Pss = [[1],[2,2,2],[3,3,3],[4,4,4]]    ;
X = 2,             Y = 4,             Pss = [[1],[2,2,2],[3,3],[4,4,4,4]]    ;
X = 2,             dif(Y,3),dif(Y,4), Pss = [[1],[2,2,2],[3,3],[Y],[4,4,4]]  ;
X = Y,             Y = 3,             Pss = [[1],[2,2],[3,3,3,3],[4,4,4]]    ;
X = 3,             Y = 4,             Pss = [[1],[2,2],[3,3,3],[4,4,4,4]]    ;
X = 3,             dif(Y,3),dif(Y,4), Pss = [[1],[2,2],[3,3,3],[Y],[4,4,4]]  ;
dif(X,2),dif(X,3), Y = 3,             Pss = [[1],[2,2],[X],[3,3,3],[4,4,4]]  ;
dif(X,2),dif(X,3), Y = 4,             Pss = [[1],[2,2],[X],[3,3],[4,4,4,4]]  ;
dif(X,2),dif(X,3), dif(Y,3),dif(Y,4), Pss = [[1],[2,2],[X],[3,3],[Y],[4,4,4]].

编辑 2015-05-05

这是tpartition/4

tpartition(P_2,List,Ts,Fs) :- tpartition_ts_fs_(List,Ts,Fs,P_2).

tpartition_ts_fs_([],[],[],_).
tpartition_ts_fs_([X|Xs0],Ts,Fs,P_2) :-
   if_(call(P_2,X), (Ts = [X|Ts0], Fs = Fs0),
                    (Ts = Ts0,     Fs = [X|Fs0])),
   tpartition_ts_fs_(Xs0,Ts0,Fs0,P_2).

样品用途:

?- tpartition(=(0), [1,2,3,4,0,1,2,3,0,0,1], Ts, Fs).
Ts = [0, 0, 0],
Fs = [1, 2, 3, 4, 1, 2, 3, 1].

编辑 2015-05-15

不断地,......这里是splitlistIf/3

split_if(P_2,As,Bss) :- splitlistIf(P_2,As,Bss).

splitlistIf(P_2,As,Bss) :-
   list_pred_split(As,P_2,Bss).

list_pred_split([],_,[]).
list_pred_split([X|Xs],P_2,Bss) :-
   if_(call(P_2,X), list_pred_split(Xs,P_2,Bss),
                    (Bss = [[X|Ys]|Bss0], list_pred_open_split(Xs,P_2,Ys,Bss0))).

list_pred_open_split([],_,[],[]).
list_pred_open_split([X|Xs],P_2,Ys,Bss) :-
   if_(call(P_2,X), (Ys = [],      list_pred_split(Xs,P_2,Bss)),
                    (Ys = [X|Ys0], list_pred_open_split(Xs,P_2,Ys0,Bss))).

让我们使用它:

?- splitlistIf(=(x),[x,1,2,x,1,2,3,x,1,4,x,x,x,x,1,x,2,x,x,1],Xs).
Xs = [[1, 2], [1, 2, 3], [1, 4], [1], [2], [1]].
于 2015-04-25T16:02:43.133 回答
3

mapadj/4之前的答案中提出的完全一样......也许这个名字更好。

forallAdj(P_2,Xs) :-
   list_forallAdj(Xs,P_2).

list_forallAdj([],_).
list_forallAdj([X|Xs],P_2) :-
   list_forallAdj_prev(Xs,P_2,X).

list_forallAdj_prev([],_,_).
list_forallAdj_prev([X1|Xs],P_2,X0) :-
   call(P_2,X0,X1),
   list_forallAdj_prev(Xs,P_2,X1).

样品用途:

:- use_module(library(clpfd)).
:- use_module(library(lambda)).

?- Ls = [0,_,_,_,_,_], forallAdj(\X0^X1^(X0 + 1 #= X1), Ls).
Ls = [0, 1, 2, 3, 4, 5].

这能把我们带到哪里?

  • forallAdj=>existAdj
  • 可能带有索引 ( forallAdjI, existAdjI) 的变体,例如Collections.List 模块 (F#)
  • findfirstAdj/pickfirstAdj也喜欢 F# find/pick
于 2015-05-15T02:06:04.513 回答