File: ordsets.pl

package info (click to toggle)
swi-prolog 8.0.2+dfsg-3+deb10u1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 72,036 kB
  • sloc: ansic: 349,612; perl: 306,654; java: 5,208; cpp: 4,436; sh: 3,042; ruby: 1,594; yacc: 845; makefile: 136; xml: 82; sed: 12; sql: 6
file content (438 lines) | stat: -rw-r--r-- 14,430 bytes parent folder | download | duplicates (2)
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
/*  Part of SWI-Prolog

    Author:        Jan Wielemaker
    E-mail:        J.Wielemaker@vu.nl
    WWW:           http://www.swi-prolog.org
    Copyright (c)  2001-2014, University of Amsterdam
                              VU University Amsterdam
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in
       the documentation and/or other materials provided with the
       distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.
*/

:- module(ordsets,
          [ is_ordset/1,                % @Term
            list_to_ord_set/2,          % +List, -OrdSet
            ord_add_element/3,          % +Set, +Element, -NewSet
            ord_del_element/3,          % +Set, +Element, -NewSet
            ord_selectchk/3,            % +Item, ?Set1, ?Set2
            ord_intersect/2,            % +Set1, +Set2 (test non-empty)
            ord_intersect/3,            % +Set1, +Set2, -Intersection
            ord_intersection/3,         % +Set1, +Set2, -Intersection
            ord_intersection/4,         % +Set1, +Set2, -Intersection, -Diff
            ord_disjoint/2,             % +Set1, +Set2
            ord_subtract/3,             % +Set, +Delete, -Remaining
            ord_union/2,                % +SetOfOrdSets, -Set
            ord_union/3,                % +Set1, +Set2, -Union
            ord_union/4,                % +Set1, +Set2, -Union, -New
            ord_subset/2,               % +Sub, +Super (test Sub is in Super)
                                        % Non-Quintus extensions
            ord_empty/1,                % ?Set
            ord_memberchk/2,            % +Element, +Set,
            ord_symdiff/3,              % +Set1, +Set2, ?Diff
                                        % SICSTus extensions
            ord_seteq/2,                % +Set1, +Set2
            ord_intersection/2          % +PowerSet, -Intersection
          ]).
:- use_module(library(oset)).
:- set_prolog_flag(generate_debug_info, false).

/** <module> Ordered set manipulation

Ordered sets are lists with unique elements sorted to the standard order
of terms (see sort/2). Exploiting ordering,   many of the set operations
can be expressed in order N rather  than N^2 when dealing with unordered
sets that may contain duplicates. The library(ordsets) is available in a
number of Prolog implementations. Our  predicates   are  designed  to be
compatible  with  common  practice   in    the   Prolog  community.  The
implementation is incomplete and  relies   partly  on  library(oset), an
older ordered set library distributed  with SWI-Prolog. New applications
are advised to use library(ordsets).

Some  of  these  predicates  match    directly   to  corresponding  list
operations. It is advised to use the  versions from this library to make
clear you are operating on ordered sets.   An exception is member/2. See
ord_memberchk/2.

The ordsets library is based  on  the   standard  order  of  terms. This
implies it can handle  all  Prolog   terms,  including  variables.  Note
however, that the ordering is not stable  if   a  term inside the set is
further instantiated. Also  note  that   variable  ordering  changes  if
variables in the set are unified with each   other  or a variable in the
set is unified with a variable that  is `older' than the newest variable
in the set. In  practice,  this  implies   that  it  is  allowed  to use
member(X, OrdSet) on an ordered set that holds  variables only if X is a
fresh variable. In other cases one should   cease  using it as an ordset
because the order it relies on may have been changed.
*/

%!  is_ordset(@Term) is semidet.
%
%   True if Term is an ordered set.   All predicates in this library
%   expect ordered sets as input arguments.  Failing to fullfil this
%   assumption results in undefined   behaviour.  Typically, ordered
%   sets are created by predicates  from   this  library,  sort/2 or
%   setof/3.

is_ordset(Term) :-
    is_list(Term),
    is_ordset2(Term).

is_ordset2([]).
is_ordset2([H|T]) :-
    is_ordset3(T, H).

is_ordset3([], _).
is_ordset3([H2|T], H) :-
    H2 @> H,
    is_ordset3(T, H2).


%!  ord_empty(?List) is semidet.
%
%   True when List is the  empty   ordered  set. Simply unifies list
%   with the empty list. Not part of Quintus.

ord_empty([]).


%!  ord_seteq(+Set1, +Set2) is semidet.
%
%   True if Set1 and Set2  have  the   same  elements.  As  both are
%   canonical sorted lists, this is the same as ==/2.
%
%   @compat sicstus

ord_seteq(Set1, Set2) :-
    Set1 == Set2.


%!  list_to_ord_set(+List, -OrdSet) is det.
%
%   Transform a list into an ordered set.  This is the same as
%   sorting the list.

list_to_ord_set(List, Set) :-
    sort(List, Set).


%!  ord_intersect(+Set1, +Set2) is semidet.
%
%   True if both ordered sets have a non-empty intersection.

ord_intersect([H1|T1], L2) :-
    ord_intersect_(L2, H1, T1).

ord_intersect_([H2|T2], H1, T1) :-
    compare(Order, H1, H2),
    ord_intersect__(Order, H1, T1, H2, T2).

ord_intersect__(<, _H1, T1,  H2, T2) :-
    ord_intersect_(T1, H2, T2).
ord_intersect__(=, _H1, _T1, _H2, _T2).
ord_intersect__(>, H1, T1,  _H2, T2) :-
    ord_intersect_(T2, H1, T1).


%!  ord_disjoint(+Set1, +Set2) is semidet.
%
%   True if Set1 and Set2  have  no   common  elements.  This is the
%   negation of ord_intersect/2.

ord_disjoint(Set1, Set2) :-
    \+ ord_intersect(Set1, Set2).


%!  ord_intersect(+Set1, +Set2, -Intersection)
%
%   Intersection  holds  the  common  elements  of  Set1  and  Set2.
%
%   @deprecated Use ord_intersection/3

ord_intersect(Set1, Set2, Intersection) :-
    oset_int(Set1, Set2, Intersection).


%!  ord_intersection(+PowerSet, -Intersection)
%
%   Intersection of a powerset. True when Intersection is an ordered
%   set holding all elements common to all sets in PowerSet.
%
%   @compat sicstus

ord_intersection(PowerSet, Intersection) :-
    key_by_length(PowerSet, Pairs),
    keysort(Pairs, [_-S|Sorted]),
    l_int(Sorted, S, Intersection).

key_by_length([], []).
key_by_length([H|T0], [L-H|T]) :-
    length(H, L),
    key_by_length(T0, T).

l_int([], S, S).
l_int([_-H|T], S0, S) :-
    ord_intersection(S0, H, S1),
    l_int(T, S1, S).


%!  ord_intersection(+Set1, +Set2, -Intersection) is det.
%
%   Intersection holds the common elements of Set1 and Set2.  Uses
%   ord_disjoint/2 if Intersection is bound to `[]` on entry.

ord_intersection(Set1, Set2, Intersection) :-
    (   Intersection == []
    ->  ord_disjoint(Set1, Set2)
    ;   oset_int(Set1, Set2, Intersection)
    ).


%!  ord_intersection(+Set1, +Set2, ?Intersection, ?Difference) is det.
%
%   Intersection  and  difference   between    two   ordered   sets.
%   Intersection is the intersection between   Set1  and Set2, while
%   Difference is defined by ord_subtract(Set2, Set1, Difference).
%
%   @see ord_intersection/3 and ord_subtract/3.

ord_intersection([], L, [], L) :- !.
ord_intersection([_|_], [], [], []) :- !.
ord_intersection([H1|T1], [H2|T2], Intersection, Difference) :-
    compare(Diff, H1, H2),
    ord_intersection2(Diff, H1, T1, H2, T2, Intersection, Difference).

ord_intersection2(=, H1, T1, _H2, T2, [H1|T], Difference) :-
    ord_intersection(T1, T2, T, Difference).
ord_intersection2(<, _, T1, H2, T2, Intersection, Difference) :-
    ord_intersection(T1, [H2|T2], Intersection, Difference).
ord_intersection2(>, H1, T1, H2, T2, Intersection, [H2|HDiff]) :-
    ord_intersection([H1|T1], T2, Intersection, HDiff).


%!  ord_add_element(+Set1, +Element, ?Set2) is det.
%
%   Insert  an  element  into  the  set.    This   is  the  same  as
%   ord_union(Set1, [Element], Set2).

ord_add_element(Set1, Element, Set2) :-
    oset_addel(Set1, Element, Set2).


%!  ord_del_element(+Set, +Element, -NewSet) is det.
%
%   Delete an element from an  ordered  set.   This  is  the same as
%   ord_subtract(Set, [Element], NewSet).

ord_del_element(Set, Element, NewSet) :-
    oset_delel(Set, Element, NewSet).


%!  ord_selectchk(+Item, ?Set1, ?Set2) is semidet.
%
%   Selectchk/3,  specialised  for  ordered  sets.    Is  true  when
%   select(Item, Set1, Set2) and Set1, Set2   are  both sorted lists
%   without duplicates. This implementation is only expected to work
%   for Item ground and either Set1 or Set2 ground. The "chk" suffix
%   is meant to remind you of   memberchk/2,  which also expects its
%   first  argument  to  be  ground.    ord_selectchk(X,  S,  T)  =>
%   ord_memberchk(X, S) & \+ ord_memberchk(X, T).
%
%   @author Richard O'Keefe

ord_selectchk(Item, [X|Set1], [X|Set2]) :-
    X @< Item,
    !,
    ord_selectchk(Item, Set1, Set2).
ord_selectchk(Item, [Item|Set1], Set1) :-
    (   Set1 == []
    ->  true
    ;   Set1 = [Y|_]
    ->  Item @< Y
    ).


%!  ord_memberchk(+Element, +OrdSet) is semidet.
%
%   True if Element is a member of   OrdSet, compared using ==. Note
%   that _enumerating_ elements of an ordered  set can be done using
%   member/2.
%
%   Some Prolog implementations also provide  ord_member/2, with the
%   same semantics as ord_memberchk/2.  We   believe  that  having a
%   semidet ord_member/2 is unacceptably inconsistent with the *_chk
%   convention.  Portable  code  should    use   ord_memberchk/2  or
%   member/2.
%
%   @author Richard O'Keefe

ord_memberchk(Item, [X1,X2,X3,X4|Xs]) :-
    !,
    compare(R4, Item, X4),
    (   R4 = (>) -> ord_memberchk(Item, Xs)
    ;   R4 = (<) ->
        compare(R2, Item, X2),
        (   R2 = (>) -> Item == X3
        ;   R2 = (<) -> Item == X1
        ;/* R2 = (=),   Item == X2 */ true
        )
    ;/* R4 = (=) */ true
    ).
ord_memberchk(Item, [X1,X2|Xs]) :-
    !,
    compare(R2, Item, X2),
    (   R2 = (>) -> ord_memberchk(Item, Xs)
    ;   R2 = (<) -> Item == X1
    ;/* R2 = (=) */ true
    ).
ord_memberchk(Item, [X1]) :-
    Item == X1.


%!  ord_subset(+Sub, +Super) is semidet.
%
%   Is true if all elements of Sub are in Super

ord_subset([], _).
ord_subset([H1|T1], [H2|T2]) :-
    compare(Order, H1, H2),
    ord_subset_(Order, H1, T1, T2).

ord_subset_(>, H1, T1, [H2|T2]) :-
    compare(Order, H1, H2),
    ord_subset_(Order, H1, T1, T2).
ord_subset_(=, _, T1, T2) :-
    ord_subset(T1, T2).


%!  ord_subtract(+InOSet, +NotInOSet, -Diff) is det.
%
%   Diff is the set holding all elements of InOSet that are not in
%   NotInOSet.

ord_subtract(InOSet, NotInOSet, Diff) :-
    oset_diff(InOSet, NotInOSet, Diff).


%!  ord_union(+SetOfSets, -Union) is det.
%
%   True if Union is the  union  of   all  elements  in the superset
%   SetOfSets. Each member of SetOfSets must  be an ordered set, the
%   sets need not be ordered in any way.
%
%   @author Copied from YAP, probably originally by Richard O'Keefe.

ord_union([], []).
ord_union([Set|Sets], Union) :-
    length([Set|Sets], NumberOfSets),
    ord_union_all(NumberOfSets, [Set|Sets], Union, []).

ord_union_all(N, Sets0, Union, Sets) :-
    (   N =:= 1
    ->  Sets0 = [Union|Sets]
    ;   N =:= 2
    ->  Sets0 = [Set1,Set2|Sets],
        ord_union(Set1,Set2,Union)
    ;   A is N>>1,
        Z is N-A,
        ord_union_all(A, Sets0, X, Sets1),
        ord_union_all(Z, Sets1, Y, Sets),
        ord_union(X, Y, Union)
    ).


%!  ord_union(+Set1, +Set2, ?Union) is det.
%
%   Union is the union of Set1 and Set2

ord_union(Set1, Set2, Union) :-
    oset_union(Set1, Set2, Union).


%!  ord_union(+Set1, +Set2, -Union, -New) is det.
%
%   True iff ord_union(Set1, Set2, Union) and
%   ord_subtract(Set2, Set1, New).

ord_union([], Set2, Set2, Set2).
ord_union([H|T], Set2, Union, New) :-
    ord_union_1(Set2, H, T, Union, New).

ord_union_1([], H, T, [H|T], []).
ord_union_1([H2|T2], H, T, Union, New) :-
    compare(Order, H, H2),
    ord_union(Order, H, T, H2, T2, Union, New).

ord_union(<, H, T, H2, T2, [H|Union], New) :-
    ord_union_2(T, H2, T2, Union, New).
ord_union(>, H, T, H2, T2, [H2|Union], [H2|New]) :-
    ord_union_1(T2, H, T, Union, New).
ord_union(=, H, T, _, T2, [H|Union], New) :-
    ord_union(T, T2, Union, New).

ord_union_2([], H2, T2, [H2|T2], [H2|T2]).
ord_union_2([H|T], H2, T2, Union, New) :-
    compare(Order, H, H2),
    ord_union(Order, H, T, H2, T2, Union, New).


%!  ord_symdiff(+Set1, +Set2, ?Difference) is det.
%
%   Is true when Difference is the  symmetric difference of Set1 and
%   Set2. I.e., Difference contains all elements that are not in the
%   intersection of Set1 and Set2. The semantics  is the same as the
%   sequence below (but the actual   implementation  requires only a
%   single scan).
%
%     ==
%           ord_union(Set1, Set2, Union),
%           ord_intersection(Set1, Set2, Intersection),
%           ord_subtract(Union, Intersection, Difference).
%     ==
%
%   For example:
%
%     ==
%     ?- ord_symdiff([1,2], [2,3], X).
%     X = [1,3].
%     ==

ord_symdiff([], Set2, Set2).
ord_symdiff([H1|T1], Set2, Difference) :-
    ord_symdiff(Set2, H1, T1, Difference).

ord_symdiff([], H1, T1, [H1|T1]).
ord_symdiff([H2|T2], H1, T1, Difference) :-
    compare(Order, H1, H2),
    ord_symdiff(Order, H1, T1, H2, T2, Difference).

ord_symdiff(<, H1, Set1, H2, T2, [H1|Difference]) :-
    ord_symdiff(Set1, H2, T2, Difference).
ord_symdiff(=, _, T1, _, T2, Difference) :-
    ord_symdiff(T1, T2, Difference).
ord_symdiff(>, H1, T1, H2, Set2, [H2|Difference]) :-
    ord_symdiff(Set2, H1, T1, Difference).