mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-13 04:44:39 +00:00
relation__rtc was just plain broken. Rather than try to fix an
Estimated hours taken: 3 relation__rtc was just plain broken. Rather than try to fix an algorithm which I pulled out of an obscure paper some years ago, it's now replaced with a slightly less efficient algorithm which is much easier to understand. library/relation.m: Changes detailed above. tests/Makefile: tests/rtc_bug.m: tests/rtc_bug.exp: Test case for the above change. tests/relation_test.m: tests/relation_test.exp: Change in output format to make debugging easier.
This commit is contained in:
Andrew Bromage
@@ -982,125 +982,77 @@ relation__detect_fake_reflexives(Rel, Rtc, [X | Xs], FakeRefl) :-
|
||||
|
||||
%------------------------------------------------------------------------------%
|
||||
|
||||
% relation__rtc returns the reflexive transitive
|
||||
% closure of a relation. This uses the algorithm
|
||||
% of Eve and Kurki-Suonio. See:
|
||||
% relation__rtc returns the reflexive transitive closure
|
||||
% of a relation.
|
||||
%
|
||||
% Eve and Kurki-Suonio, "On computing the
|
||||
% transitive closure of a relation", Acta
|
||||
% Informatica, 8, pp 303--314, 1977
|
||||
relation__rtc(Rel, Rtc) :-
|
||||
relation__domain_sorted_list(Rel, DomList),
|
||||
list__length(DomList, DomLen),
|
||||
map__init(Map0),
|
||||
relation__rtc_init_map(Map0, DomList, Map),
|
||||
% Note: This is not the most efficient algorithm (in the sense
|
||||
% of minimal number of arc insertions) possible. However it
|
||||
% "reasonably" efficient and, more importantly, is much easier
|
||||
% to debug than some others.
|
||||
%
|
||||
% The algorithm is very simple, and is based on the
|
||||
% observation that the RTC of any element in a clique is the
|
||||
% same as the RTC of any other element in that clique. So
|
||||
% we visit each clique in reverse topological sorted order,
|
||||
% compute the RTC for each element in the clique and then
|
||||
% add the appropriate arcs.
|
||||
%
|
||||
relation__rtc(Rel, RTC) :-
|
||||
relation__dfs(Rel, Dfs),
|
||||
set_bbbtree__init(Visit),
|
||||
|
||||
% Make a new relation using the same domain as the old one.
|
||||
Rel = relation(NextElement, ElMap, _, _),
|
||||
map__init(FwdMap),
|
||||
map__init(BwdMap),
|
||||
RtcIn = relation(NextElement, ElMap, FwdMap, BwdMap),
|
||||
RTC0 = relation(NextElement, ElMap, FwdMap, BwdMap),
|
||||
|
||||
Inf is (DomLen + 2) * 2, % This is close enough to infinity.
|
||||
relation__rtc_2(Inf, Rel, DomList, Map, RtcIn, Rtc).
|
||||
relation__rtc_2(Dfs, Rel, Visit, RTC0, RTC).
|
||||
|
||||
% relation__rtc_init_map takes a domain Xs and creates a map
|
||||
% Map such that:
|
||||
%
|
||||
% all [X]
|
||||
% (
|
||||
% list__member(X, Xs) =>
|
||||
% map__lookup(Map, X, 0)
|
||||
% ).
|
||||
%
|
||||
% Question: Would an "array" type which allows an
|
||||
% arbitrary domain (not just integers) be a better
|
||||
% solution? About the only differences between this
|
||||
% and a "map" would be the ease of initialisation,
|
||||
% and the semi-static nature of the domain. (Arrays
|
||||
% can be resized.)
|
||||
:- pred relation__rtc_init_map(map(relation_key, int), list(relation_key),
|
||||
map(relation_key, int)).
|
||||
:- mode relation__rtc_init_map(in, in, out) is det.
|
||||
relation__rtc_init_map(Map, [], Map).
|
||||
relation__rtc_init_map(MapIn, [ X | Xs ], MapOut) :-
|
||||
map__det_insert(MapIn, X, 0, Map1),
|
||||
relation__rtc_init_map(Map1, Xs, MapOut).
|
||||
:- pred relation__rtc_2(list(relation_key), relation(T),
|
||||
set_bbbtree(relation_key), relation(T), relation(T)).
|
||||
:- mode relation__rtc_2(in, in, in, in, out) is det.
|
||||
|
||||
:- pred relation__rtc_2(int, relation(T), list(relation_key),
|
||||
map(relation_key, int), relation(T), relation(T)).
|
||||
:- mode relation__rtc_2(in, in, in, in, in, out) is det.
|
||||
relation__rtc_2(_, _, [], _, Rtc, Rtc).
|
||||
relation__rtc_2(Inf, Rel, [ X | Xs ], Map, RtcIn, RtcOut) :-
|
||||
( map__lookup(Map, X, 0) ->
|
||||
stack__init(S0),
|
||||
rtc(Inf, Rel, X, 1, S0, _S1, Map, Map1, RtcIn, Rtc1)
|
||||
relation__rtc_2([], _, _, RTC, RTC).
|
||||
relation__rtc_2([H | T], Rel, Visit0, RTC0, RTC) :-
|
||||
( set_bbbtree__member(H, Visit0) ->
|
||||
relation__rtc_2(T, Rel, Visit0, RTC0, RTC)
|
||||
;
|
||||
Map = Map1, RtcIn = Rtc1
|
||||
),
|
||||
relation__rtc_2(Inf, Rel, Xs, Map1, Rtc1, RtcOut).
|
||||
|
||||
% When the arity gets this big, it's probably worth
|
||||
% considering making a state type...
|
||||
:- pred rtc(int, relation(T), relation_key, int, stack(relation_key),
|
||||
stack(relation_key), map(relation_key, int), map(relation_key, int),
|
||||
relation(T), relation(T)).
|
||||
:- mode rtc(in, in, in, in, in, out, in, out, in, out) is det.
|
||||
rtc(Inf, Rel, A, K, S0, S1, MapIn, MapOut, RtcIn, RtcOut) :-
|
||||
K1 is K + 1,
|
||||
stack__push(S0, A, S2),
|
||||
map__set(MapIn, A, K, Map1),
|
||||
relation__add(RtcIn, A, A, Rtc1),
|
||||
relation__lookup_from(Rel, A, BsSet),
|
||||
set__to_sorted_list(BsSet, BsList),
|
||||
rtc_2(Inf, Rel, A, K1, BsList, S2, S3, Map1, Map2, Rtc1, Rtc2),
|
||||
( map__lookup(Map2, A, K) ->
|
||||
rtc_3(Inf, A, Map2, Map3, S3, S4, Rtc2, Rtc3)
|
||||
;
|
||||
Map2=Map3, S3=S4, Rtc2=Rtc3
|
||||
),
|
||||
Map3=MapOut, Rtc3=RtcOut, S1=S4.
|
||||
|
||||
:- pred rtc_2(int, relation(T), relation_key, int, list(relation_key),
|
||||
stack(relation_key), stack(relation_key), map(relation_key, int),
|
||||
map(relation_key, int), relation(T), relation(T)).
|
||||
:- mode rtc_2(in, in, in, in, in, in, out, in, out, in, out) is det.
|
||||
rtc_2(_Inf, _Rel, _A, _K1, [], Stack, Stack, Map, Map, Rtc, Rtc).
|
||||
rtc_2(Inf, Rel, A, K1, [B | Bs], S0, S1, Map0, Map1, Rtc0, Rtc1) :-
|
||||
( map__lookup(Map0, B, 0) ->
|
||||
rtc(Inf, Rel, B, K1, S0, S2, Map0, Map2, Rtc0, Rtc2)
|
||||
;
|
||||
S0=S2, Map0=Map2, Rtc0=Rtc2
|
||||
),
|
||||
map__lookup(Map2, A, Na),
|
||||
map__lookup(Map2, B, Nb),
|
||||
( Na =< Nb ->
|
||||
Map2 = Map3
|
||||
;
|
||||
map__set(Map2, A, Nb, Map3)
|
||||
),
|
||||
relation__lookup_from(Rtc2, B, RtcBSet),
|
||||
set__to_sorted_list(RtcBSet, RtcB),
|
||||
relation__append_to(A, RtcB, RtcA),
|
||||
relation__add_assoc_list(Rtc2, RtcA, Rtc3),
|
||||
rtc_2(Inf, Rel, A, K1, Bs, S2, S1, Map3, Map1, Rtc3, Rtc1).
|
||||
|
||||
:- pred rtc_3(int, relation_key, map(relation_key, int), map(relation_key, int),
|
||||
stack(relation_key), stack(relation_key), relation(T),
|
||||
relation(T)).
|
||||
:- mode rtc_3(in, in, in, out, in, out, in, out) is det.
|
||||
rtc_3(Inf, A, MapIn, MapOut, S0, S1, RtcIn, RtcOut) :-
|
||||
stack__pop_det(S0, B, S2),
|
||||
( A = B ->
|
||||
MapIn=MapOut, S1=S2, RtcIn=RtcOut
|
||||
;
|
||||
relation__lookup_from(RtcIn, A, RtcASet),
|
||||
set__to_sorted_list(RtcASet, RtcA),
|
||||
relation__append_to(B, RtcA, RtcB),
|
||||
relation__add_assoc_list(RtcIn, RtcB, Rtc1),
|
||||
map__set(MapIn, B, Inf, Map1),
|
||||
rtc_3(Inf, A, Map1, MapOut, S2, S1, Rtc1, RtcOut)
|
||||
relation__dfs_3([H], Rel, Visit0, [], Visit, CliqueL0),
|
||||
list__sort_and_remove_dups(CliqueL0, CliqueL),
|
||||
list__foldl(lambda([K :: in, L0 :: in, L :: out] is det,
|
||||
( relation__lookup_from(Rel, K, Followers0),
|
||||
set__to_sorted_list(Followers0, Followers),
|
||||
list__merge_and_remove_dups(Followers, L0, L)
|
||||
)),
|
||||
CliqueL, CliqueL, CliqueFollowers),
|
||||
list__foldl(lambda([K :: in, L0 :: in, L :: out] is det,
|
||||
( relation__lookup_from(RTC0, K, Followers0),
|
||||
set__to_sorted_list(Followers0, Followers),
|
||||
list__merge_and_remove_dups(Followers, L0, L)
|
||||
)),
|
||||
CliqueFollowers, CliqueL, NewFollowers),
|
||||
relation__add_cartesian_product(CliqueL, NewFollowers,
|
||||
RTC0, RTC1),
|
||||
relation__rtc_2(T, Rel, Visit, RTC1, RTC)
|
||||
).
|
||||
|
||||
:- pred relation__add_cartesian_product(list(relation_key), list(relation_key),
|
||||
relation(T), relation(T)).
|
||||
:- mode relation__add_cartesian_product(in, in, in, out) is det.
|
||||
|
||||
relation__add_cartesian_product([], _, RTC, RTC).
|
||||
relation__add_cartesian_product([K1 | Ks1], Ks2, RTC0, RTC) :-
|
||||
relation__add_cartesian_product_2(K1, Ks2, RTC0, RTC1),
|
||||
relation__add_cartesian_product(Ks1, Ks2, RTC1, RTC).
|
||||
|
||||
:- pred relation__add_cartesian_product_2(relation_key, list(relation_key),
|
||||
relation(T), relation(T)).
|
||||
:- mode relation__add_cartesian_product_2(in, in, in, out) is det.
|
||||
|
||||
relation__add_cartesian_product_2(_, [], RTC, RTC).
|
||||
relation__add_cartesian_product_2(K1, [K2 | Ks2], RTC0, RTC) :-
|
||||
relation__add(RTC0, K1, K2, RTC1),
|
||||
relation__add_cartesian_product_2(K1, Ks2, RTC1, RTC).
|
||||
|
||||
%------------------------------------------------------------------------------%
|
||||
%------------------------------------------------------------------------------%
|
||||
|
||||
@@ -53,6 +53,7 @@ PROGS= array_test \
|
||||
petdr1 \
|
||||
prune_switch \
|
||||
relation_test \
|
||||
rtc_bug \
|
||||
semidet_map \
|
||||
set_test \
|
||||
string_format_test \
|
||||
|
||||
@@ -1,5 +1,60 @@
|
||||
Rel = ["a" - "b", "b" - "c", "c" - "d", "l2" - "l3", "l1" - "l2", "l3" - "l1", "x" - "x"]
|
||||
tc of Rel = ["a" - "c", "a" - "d", "a" - "b", "b" - "c", "b" - "d", "c" - "d", "l2" - "l3", "l2" - "l1", "l2" - "l2", "l1" - "l3", "l1" - "l1", "l1" - "l2", "l3" - "l3", "l3" - "l1", "l3" - "l2", "x" - "x"]
|
||||
rtc of Rel = ["a" - "c", "a" - "d", "a" - "b", "a" - "a", "b" - "c", "b" - "d", "b" - "b", "d" - "d", "c" - "c", "c" - "d", "l2" - "l3", "l2" - "l1", "l2" - "l2", "l1" - "l3", "l1" - "l1", "l1" - "l2", "l3" - "l3", "l3" - "l1", "l3" - "l2", "x" - "x"]
|
||||
Rel2 = ["a" - "a1", "b" - "b1", "c" - "c1", "d" - "d1"]
|
||||
composition of Rel1 and Rel2 = ["c" - "d1", "b" - "c1", "a" - "b1"]
|
||||
Rel =
|
||||
"a" - "b"
|
||||
"b" - "c"
|
||||
"c" - "d"
|
||||
"l1" - "l2"
|
||||
"l2" - "l3"
|
||||
"l3" - "l1"
|
||||
"x" - "x"
|
||||
|
||||
tc of Rel =
|
||||
"a" - "b"
|
||||
"a" - "c"
|
||||
"a" - "d"
|
||||
"b" - "c"
|
||||
"b" - "d"
|
||||
"c" - "d"
|
||||
"l1" - "l1"
|
||||
"l1" - "l2"
|
||||
"l1" - "l3"
|
||||
"l2" - "l1"
|
||||
"l2" - "l2"
|
||||
"l2" - "l3"
|
||||
"l3" - "l1"
|
||||
"l3" - "l2"
|
||||
"l3" - "l3"
|
||||
"x" - "x"
|
||||
|
||||
rtc of Rel =
|
||||
"a" - "a"
|
||||
"a" - "b"
|
||||
"a" - "c"
|
||||
"a" - "d"
|
||||
"b" - "b"
|
||||
"b" - "c"
|
||||
"b" - "d"
|
||||
"c" - "c"
|
||||
"c" - "d"
|
||||
"d" - "d"
|
||||
"l1" - "l1"
|
||||
"l1" - "l2"
|
||||
"l1" - "l3"
|
||||
"l2" - "l1"
|
||||
"l2" - "l2"
|
||||
"l2" - "l3"
|
||||
"l3" - "l1"
|
||||
"l3" - "l2"
|
||||
"l3" - "l3"
|
||||
"x" - "x"
|
||||
|
||||
Rel2 =
|
||||
"a" - "a1"
|
||||
"b" - "b1"
|
||||
"c" - "c1"
|
||||
"d" - "d1"
|
||||
|
||||
composition of Rel1 and Rel2 =
|
||||
"a" - "b1"
|
||||
"b" - "c1"
|
||||
"c" - "d1"
|
||||
|
||||
|
||||
@@ -26,16 +26,18 @@ main -->
|
||||
{ relation__tc(Rel, TC_Rel) },
|
||||
{ relation__rtc(Rel, RTC_Rel) },
|
||||
{ relation__compose(Rel, Rel2, ComposedRel) },
|
||||
print("Rel = "), print_rel(Rel), nl,
|
||||
print("tc of Rel = "), print_rel(TC_Rel), nl,
|
||||
print("rtc of Rel = "), print_rel(RTC_Rel), nl,
|
||||
print("Rel2 = "), print_rel(Rel2), nl,
|
||||
print("composition of Rel1 and Rel2 = "), print_rel(ComposedRel), nl.
|
||||
print("Rel ="), nl, print_rel(Rel), nl,
|
||||
print("tc of Rel ="), nl, print_rel(TC_Rel), nl,
|
||||
print("rtc of Rel ="), nl, print_rel(RTC_Rel), nl,
|
||||
print("Rel2 ="), nl, print_rel(Rel2), nl,
|
||||
print("composition of Rel1 and Rel2 ="), nl,
|
||||
print_rel(ComposedRel), nl.
|
||||
|
||||
:- pred print_rel(relation(T), state, state).
|
||||
:- mode print_rel(in, di, uo) is det.
|
||||
|
||||
print_rel(Relation) -->
|
||||
{ relation__to_assoc_list(Relation, AssocList) },
|
||||
print(AssocList).
|
||||
{ relation__to_assoc_list(Relation, AssocList0) },
|
||||
{ list__sort(AssocList0, AssocList) },
|
||||
write_list(AssocList, "\n", print), nl.
|
||||
|
||||
|
||||
421
tests/general/rtc_bug.exp
Normal file
421
tests/general/rtc_bug.exp
Normal file
@@ -0,0 +1,421 @@
|
||||
L:
|
||||
"varset" - "mercury_builtin"
|
||||
"varset" - "list"
|
||||
"varset" - "assoc_list"
|
||||
"varset" - "map"
|
||||
"varset" - "term"
|
||||
"term" - "mercury_builtin"
|
||||
"term" - "list"
|
||||
"term" - "std_util"
|
||||
"term" - "map"
|
||||
"store" - "mercury_builtin"
|
||||
"stack" - "mercury_builtin"
|
||||
"stack" - "list"
|
||||
"set_unordlist" - "mercury_builtin"
|
||||
"set_unordlist" - "list"
|
||||
"set_unordlist" - "bool"
|
||||
"set_ordlist" - "mercury_builtin"
|
||||
"set_ordlist" - "list"
|
||||
"set_ordlist" - "bool"
|
||||
"require" - "mercury_builtin"
|
||||
"set_bbbtree" - "mercury_builtin"
|
||||
"set_bbbtree" - "list"
|
||||
"set_bbbtree" - "bool"
|
||||
"relation" - "mercury_builtin"
|
||||
"relation" - "list"
|
||||
"relation" - "assoc_list"
|
||||
"relation" - "set"
|
||||
"relation" - "set_bbbtree"
|
||||
"rbtree" - "mercury_builtin"
|
||||
"rbtree" - "list"
|
||||
"rbtree" - "assoc_list"
|
||||
"random" - "mercury_builtin"
|
||||
"random" - "list"
|
||||
"queue" - "mercury_builtin"
|
||||
"queue" - "list"
|
||||
"prolog" - "mercury_builtin"
|
||||
"prolog" - "list"
|
||||
"prolog" - "std_util"
|
||||
"pqueue" - "mercury_builtin"
|
||||
"pqueue" - "assoc_list"
|
||||
"term_io" - "mercury_builtin"
|
||||
"term_io" - "char"
|
||||
"term_io" - "io"
|
||||
"term_io" - "term"
|
||||
"term_io" - "varset"
|
||||
"parser" - "mercury_builtin"
|
||||
"parser" - "io"
|
||||
"parser" - "term_io"
|
||||
"multi_map" - "mercury_builtin"
|
||||
"multi_map" - "list"
|
||||
"multi_map" - "assoc_list"
|
||||
"multi_map" - "map"
|
||||
"multi_map" - "set"
|
||||
"math" - "mercury_builtin"
|
||||
"tree234" - "mercury_builtin"
|
||||
"tree234" - "list"
|
||||
"tree234" - "assoc_list"
|
||||
"library" - "mercury_builtin"
|
||||
"lexer" - "mercury_builtin"
|
||||
"lexer" - "char"
|
||||
"lexer" - "io"
|
||||
"ops" - "mercury_builtin"
|
||||
"string" - "mercury_builtin"
|
||||
"string" - "list"
|
||||
"string" - "char"
|
||||
"io" - "mercury_builtin"
|
||||
"io" - "list"
|
||||
"io" - "std_util"
|
||||
"io" - "char"
|
||||
"io" - "string"
|
||||
"io" - "ops"
|
||||
"group" - "mercury_builtin"
|
||||
"group" - "list"
|
||||
"group" - "assoc_list"
|
||||
"group" - "set"
|
||||
"graph" - "mercury_builtin"
|
||||
"graph" - "list"
|
||||
"graph" - "std_util"
|
||||
"graph" - "set"
|
||||
"getopt" - "mercury_builtin"
|
||||
"getopt" - "list"
|
||||
"getopt" - "std_util"
|
||||
"getopt" - "map"
|
||||
"getopt" - "bool"
|
||||
"getopt" - "char"
|
||||
"float" - "mercury_builtin"
|
||||
"set" - "mercury_builtin"
|
||||
"set" - "list"
|
||||
"set" - "bool"
|
||||
"eqvclass" - "mercury_builtin"
|
||||
"eqvclass" - "list"
|
||||
"eqvclass" - "set"
|
||||
"dir" - "mercury_builtin"
|
||||
"debugger_interface" - "mercury_builtin"
|
||||
"char" - "mercury_builtin"
|
||||
"int" - "mercury_builtin"
|
||||
"bt_array" - "mercury_builtin"
|
||||
"bt_array" - "list"
|
||||
"bt_array" - "int"
|
||||
"bool" - "mercury_builtin"
|
||||
"bool" - "list"
|
||||
"bintree_set" - "mercury_builtin"
|
||||
"bintree_set" - "list"
|
||||
"bintree" - "mercury_builtin"
|
||||
"bintree" - "list"
|
||||
"bintree" - "assoc_list"
|
||||
"map" - "mercury_builtin"
|
||||
"map" - "list"
|
||||
"map" - "assoc_list"
|
||||
"map" - "set"
|
||||
"map" - "tree234"
|
||||
"bimap" - "mercury_builtin"
|
||||
"bimap" - "list"
|
||||
"bimap" - "assoc_list"
|
||||
"bimap" - "map"
|
||||
"benchmarking" - "mercury_builtin"
|
||||
"bag" - "mercury_builtin"
|
||||
"bag" - "list"
|
||||
"bag" - "assoc_list"
|
||||
"assoc_list" - "mercury_builtin"
|
||||
"assoc_list" - "list"
|
||||
"assoc_list" - "std_util"
|
||||
"std_util" - "mercury_builtin"
|
||||
"std_util" - "list"
|
||||
"std_util" - "set"
|
||||
"list" - "mercury_builtin"
|
||||
"list" - "int"
|
||||
"mercury_builtin" - "mercury_builtin"
|
||||
"array" - "mercury_builtin"
|
||||
"array" - "list"
|
||||
"array" - "std_util"
|
||||
|
||||
RTC_L:
|
||||
"array" - "array"
|
||||
"array" - "bool"
|
||||
"array" - "int"
|
||||
"array" - "list"
|
||||
"array" - "mercury_builtin"
|
||||
"array" - "set"
|
||||
"array" - "std_util"
|
||||
"assoc_list" - "assoc_list"
|
||||
"assoc_list" - "bool"
|
||||
"assoc_list" - "int"
|
||||
"assoc_list" - "list"
|
||||
"assoc_list" - "mercury_builtin"
|
||||
"assoc_list" - "set"
|
||||
"assoc_list" - "std_util"
|
||||
"bag" - "assoc_list"
|
||||
"bag" - "bag"
|
||||
"bag" - "bool"
|
||||
"bag" - "int"
|
||||
"bag" - "list"
|
||||
"bag" - "mercury_builtin"
|
||||
"bag" - "set"
|
||||
"bag" - "std_util"
|
||||
"benchmarking" - "benchmarking"
|
||||
"benchmarking" - "mercury_builtin"
|
||||
"bimap" - "assoc_list"
|
||||
"bimap" - "bimap"
|
||||
"bimap" - "bool"
|
||||
"bimap" - "int"
|
||||
"bimap" - "list"
|
||||
"bimap" - "map"
|
||||
"bimap" - "mercury_builtin"
|
||||
"bimap" - "set"
|
||||
"bimap" - "std_util"
|
||||
"bimap" - "tree234"
|
||||
"bintree" - "assoc_list"
|
||||
"bintree" - "bintree"
|
||||
"bintree" - "bool"
|
||||
"bintree" - "int"
|
||||
"bintree" - "list"
|
||||
"bintree" - "mercury_builtin"
|
||||
"bintree" - "set"
|
||||
"bintree" - "std_util"
|
||||
"bintree_set" - "bintree_set"
|
||||
"bintree_set" - "int"
|
||||
"bintree_set" - "list"
|
||||
"bintree_set" - "mercury_builtin"
|
||||
"bool" - "bool"
|
||||
"bool" - "int"
|
||||
"bool" - "list"
|
||||
"bool" - "mercury_builtin"
|
||||
"bt_array" - "bt_array"
|
||||
"bt_array" - "int"
|
||||
"bt_array" - "list"
|
||||
"bt_array" - "mercury_builtin"
|
||||
"char" - "char"
|
||||
"char" - "mercury_builtin"
|
||||
"debugger_interface" - "debugger_interface"
|
||||
"debugger_interface" - "mercury_builtin"
|
||||
"dir" - "dir"
|
||||
"dir" - "mercury_builtin"
|
||||
"eqvclass" - "bool"
|
||||
"eqvclass" - "eqvclass"
|
||||
"eqvclass" - "int"
|
||||
"eqvclass" - "list"
|
||||
"eqvclass" - "mercury_builtin"
|
||||
"eqvclass" - "set"
|
||||
"float" - "float"
|
||||
"float" - "mercury_builtin"
|
||||
"getopt" - "assoc_list"
|
||||
"getopt" - "bool"
|
||||
"getopt" - "char"
|
||||
"getopt" - "getopt"
|
||||
"getopt" - "int"
|
||||
"getopt" - "list"
|
||||
"getopt" - "map"
|
||||
"getopt" - "mercury_builtin"
|
||||
"getopt" - "set"
|
||||
"getopt" - "std_util"
|
||||
"getopt" - "tree234"
|
||||
"graph" - "bool"
|
||||
"graph" - "graph"
|
||||
"graph" - "int"
|
||||
"graph" - "list"
|
||||
"graph" - "mercury_builtin"
|
||||
"graph" - "set"
|
||||
"graph" - "std_util"
|
||||
"group" - "assoc_list"
|
||||
"group" - "bool"
|
||||
"group" - "group"
|
||||
"group" - "int"
|
||||
"group" - "list"
|
||||
"group" - "mercury_builtin"
|
||||
"group" - "set"
|
||||
"group" - "std_util"
|
||||
"int" - "int"
|
||||
"int" - "mercury_builtin"
|
||||
"io" - "bool"
|
||||
"io" - "char"
|
||||
"io" - "int"
|
||||
"io" - "io"
|
||||
"io" - "list"
|
||||
"io" - "mercury_builtin"
|
||||
"io" - "ops"
|
||||
"io" - "set"
|
||||
"io" - "std_util"
|
||||
"io" - "string"
|
||||
"lexer" - "bool"
|
||||
"lexer" - "char"
|
||||
"lexer" - "int"
|
||||
"lexer" - "io"
|
||||
"lexer" - "lexer"
|
||||
"lexer" - "list"
|
||||
"lexer" - "mercury_builtin"
|
||||
"lexer" - "ops"
|
||||
"lexer" - "set"
|
||||
"lexer" - "std_util"
|
||||
"lexer" - "string"
|
||||
"library" - "library"
|
||||
"library" - "mercury_builtin"
|
||||
"list" - "int"
|
||||
"list" - "list"
|
||||
"list" - "mercury_builtin"
|
||||
"map" - "assoc_list"
|
||||
"map" - "bool"
|
||||
"map" - "int"
|
||||
"map" - "list"
|
||||
"map" - "map"
|
||||
"map" - "mercury_builtin"
|
||||
"map" - "set"
|
||||
"map" - "std_util"
|
||||
"map" - "tree234"
|
||||
"math" - "math"
|
||||
"math" - "mercury_builtin"
|
||||
"mercury_builtin" - "mercury_builtin"
|
||||
"multi_map" - "assoc_list"
|
||||
"multi_map" - "bool"
|
||||
"multi_map" - "int"
|
||||
"multi_map" - "list"
|
||||
"multi_map" - "map"
|
||||
"multi_map" - "mercury_builtin"
|
||||
"multi_map" - "multi_map"
|
||||
"multi_map" - "set"
|
||||
"multi_map" - "std_util"
|
||||
"multi_map" - "tree234"
|
||||
"ops" - "mercury_builtin"
|
||||
"ops" - "ops"
|
||||
"parser" - "assoc_list"
|
||||
"parser" - "bool"
|
||||
"parser" - "char"
|
||||
"parser" - "int"
|
||||
"parser" - "io"
|
||||
"parser" - "list"
|
||||
"parser" - "map"
|
||||
"parser" - "mercury_builtin"
|
||||
"parser" - "ops"
|
||||
"parser" - "parser"
|
||||
"parser" - "set"
|
||||
"parser" - "std_util"
|
||||
"parser" - "string"
|
||||
"parser" - "term"
|
||||
"parser" - "term_io"
|
||||
"parser" - "tree234"
|
||||
"parser" - "varset"
|
||||
"pqueue" - "assoc_list"
|
||||
"pqueue" - "bool"
|
||||
"pqueue" - "int"
|
||||
"pqueue" - "list"
|
||||
"pqueue" - "mercury_builtin"
|
||||
"pqueue" - "pqueue"
|
||||
"pqueue" - "set"
|
||||
"pqueue" - "std_util"
|
||||
"prolog" - "bool"
|
||||
"prolog" - "int"
|
||||
"prolog" - "list"
|
||||
"prolog" - "mercury_builtin"
|
||||
"prolog" - "prolog"
|
||||
"prolog" - "set"
|
||||
"prolog" - "std_util"
|
||||
"queue" - "int"
|
||||
"queue" - "list"
|
||||
"queue" - "mercury_builtin"
|
||||
"queue" - "queue"
|
||||
"random" - "int"
|
||||
"random" - "list"
|
||||
"random" - "mercury_builtin"
|
||||
"random" - "random"
|
||||
"rbtree" - "assoc_list"
|
||||
"rbtree" - "bool"
|
||||
"rbtree" - "int"
|
||||
"rbtree" - "list"
|
||||
"rbtree" - "mercury_builtin"
|
||||
"rbtree" - "rbtree"
|
||||
"rbtree" - "set"
|
||||
"rbtree" - "std_util"
|
||||
"relation" - "assoc_list"
|
||||
"relation" - "bool"
|
||||
"relation" - "int"
|
||||
"relation" - "list"
|
||||
"relation" - "mercury_builtin"
|
||||
"relation" - "relation"
|
||||
"relation" - "set"
|
||||
"relation" - "set_bbbtree"
|
||||
"relation" - "std_util"
|
||||
"require" - "mercury_builtin"
|
||||
"require" - "require"
|
||||
"set" - "bool"
|
||||
"set" - "int"
|
||||
"set" - "list"
|
||||
"set" - "mercury_builtin"
|
||||
"set" - "set"
|
||||
"set_bbbtree" - "bool"
|
||||
"set_bbbtree" - "int"
|
||||
"set_bbbtree" - "list"
|
||||
"set_bbbtree" - "mercury_builtin"
|
||||
"set_bbbtree" - "set_bbbtree"
|
||||
"set_ordlist" - "bool"
|
||||
"set_ordlist" - "int"
|
||||
"set_ordlist" - "list"
|
||||
"set_ordlist" - "mercury_builtin"
|
||||
"set_ordlist" - "set_ordlist"
|
||||
"set_unordlist" - "bool"
|
||||
"set_unordlist" - "int"
|
||||
"set_unordlist" - "list"
|
||||
"set_unordlist" - "mercury_builtin"
|
||||
"set_unordlist" - "set_unordlist"
|
||||
"stack" - "int"
|
||||
"stack" - "list"
|
||||
"stack" - "mercury_builtin"
|
||||
"stack" - "stack"
|
||||
"std_util" - "bool"
|
||||
"std_util" - "int"
|
||||
"std_util" - "list"
|
||||
"std_util" - "mercury_builtin"
|
||||
"std_util" - "set"
|
||||
"std_util" - "std_util"
|
||||
"store" - "mercury_builtin"
|
||||
"store" - "store"
|
||||
"string" - "char"
|
||||
"string" - "int"
|
||||
"string" - "list"
|
||||
"string" - "mercury_builtin"
|
||||
"string" - "string"
|
||||
"term" - "assoc_list"
|
||||
"term" - "bool"
|
||||
"term" - "int"
|
||||
"term" - "list"
|
||||
"term" - "map"
|
||||
"term" - "mercury_builtin"
|
||||
"term" - "set"
|
||||
"term" - "std_util"
|
||||
"term" - "term"
|
||||
"term" - "tree234"
|
||||
"term_io" - "assoc_list"
|
||||
"term_io" - "bool"
|
||||
"term_io" - "char"
|
||||
"term_io" - "int"
|
||||
"term_io" - "io"
|
||||
"term_io" - "list"
|
||||
"term_io" - "map"
|
||||
"term_io" - "mercury_builtin"
|
||||
"term_io" - "ops"
|
||||
"term_io" - "set"
|
||||
"term_io" - "std_util"
|
||||
"term_io" - "string"
|
||||
"term_io" - "term"
|
||||
"term_io" - "term_io"
|
||||
"term_io" - "tree234"
|
||||
"term_io" - "varset"
|
||||
"tree234" - "assoc_list"
|
||||
"tree234" - "bool"
|
||||
"tree234" - "int"
|
||||
"tree234" - "list"
|
||||
"tree234" - "mercury_builtin"
|
||||
"tree234" - "set"
|
||||
"tree234" - "std_util"
|
||||
"tree234" - "tree234"
|
||||
"varset" - "assoc_list"
|
||||
"varset" - "bool"
|
||||
"varset" - "int"
|
||||
"varset" - "list"
|
||||
"varset" - "map"
|
||||
"varset" - "mercury_builtin"
|
||||
"varset" - "set"
|
||||
"varset" - "std_util"
|
||||
"varset" - "term"
|
||||
"varset" - "tree234"
|
||||
"varset" - "varset"
|
||||
|
||||
154
tests/general/rtc_bug.m
Normal file
154
tests/general/rtc_bug.m
Normal file
@@ -0,0 +1,154 @@
|
||||
:- module rtc_bug.
|
||||
:- interface.
|
||||
:- import_module io.
|
||||
:- pred main(state::di, state::uo) is det.
|
||||
|
||||
:- implementation.
|
||||
:- import_module relation, std_util, list.
|
||||
|
||||
main -->
|
||||
{ l(L) },
|
||||
io__print("L:"), io__nl,
|
||||
io__write_list(L, "\n", io__print), io__nl, io__nl,
|
||||
{ relation__from_assoc_list(L, R) },
|
||||
{ relation__rtc(R, RTC_R) },
|
||||
{ relation__to_assoc_list(RTC_R, RTC_L0) },
|
||||
{ list__sort(RTC_L0, RTC_L) },
|
||||
io__print("RTC_L:"), io__nl,
|
||||
io__write_list(RTC_L, "\n", io__print), io__nl, io__nl,
|
||||
[].
|
||||
|
||||
:- pred l(list(pair(string)) :: out) is det.
|
||||
l(["varset" - "mercury_builtin",
|
||||
"varset" - "list",
|
||||
"varset" - "assoc_list",
|
||||
"varset" - "map",
|
||||
"varset" - "term",
|
||||
"term" - "mercury_builtin",
|
||||
"term" - "list",
|
||||
"term" - "std_util",
|
||||
"term" - "map",
|
||||
"store" - "mercury_builtin",
|
||||
"stack" - "mercury_builtin",
|
||||
"stack" - "list",
|
||||
"set_unordlist" - "mercury_builtin",
|
||||
"set_unordlist" - "list",
|
||||
"set_unordlist" - "bool",
|
||||
"set_ordlist" - "mercury_builtin",
|
||||
"set_ordlist" - "list",
|
||||
"set_ordlist" - "bool",
|
||||
"require" - "mercury_builtin",
|
||||
"set_bbbtree" - "mercury_builtin",
|
||||
"set_bbbtree" - "list",
|
||||
"set_bbbtree" - "bool",
|
||||
"relation" - "mercury_builtin",
|
||||
"relation" - "list",
|
||||
"relation" - "assoc_list",
|
||||
"relation" - "set",
|
||||
"relation" - "set_bbbtree",
|
||||
"rbtree" - "mercury_builtin",
|
||||
"rbtree" - "list",
|
||||
"rbtree" - "assoc_list",
|
||||
"random" - "mercury_builtin",
|
||||
"random" - "list",
|
||||
"queue" - "mercury_builtin",
|
||||
"queue" - "list",
|
||||
"prolog" - "mercury_builtin",
|
||||
"prolog" - "list",
|
||||
"prolog" - "std_util",
|
||||
"pqueue" - "mercury_builtin",
|
||||
"pqueue" - "assoc_list",
|
||||
"term_io" - "mercury_builtin",
|
||||
"term_io" - "char",
|
||||
"term_io" - "io",
|
||||
"term_io" - "term",
|
||||
"term_io" - "varset",
|
||||
"parser" - "mercury_builtin",
|
||||
"parser" - "io",
|
||||
"parser" - "term_io",
|
||||
"multi_map" - "mercury_builtin",
|
||||
"multi_map" - "list",
|
||||
"multi_map" - "assoc_list",
|
||||
"multi_map" - "map",
|
||||
"multi_map" - "set",
|
||||
"math" - "mercury_builtin",
|
||||
"tree234" - "mercury_builtin",
|
||||
"tree234" - "list",
|
||||
"tree234" - "assoc_list",
|
||||
"library" - "mercury_builtin",
|
||||
"lexer" - "mercury_builtin",
|
||||
"lexer" - "char",
|
||||
"lexer" - "io",
|
||||
"ops" - "mercury_builtin",
|
||||
"string" - "mercury_builtin",
|
||||
"string" - "list",
|
||||
"string" - "char",
|
||||
"io" - "mercury_builtin",
|
||||
"io" - "list",
|
||||
"io" - "std_util",
|
||||
"io" - "char",
|
||||
"io" - "string",
|
||||
"io" - "ops",
|
||||
"group" - "mercury_builtin",
|
||||
"group" - "list",
|
||||
"group" - "assoc_list",
|
||||
"group" - "set",
|
||||
"graph" - "mercury_builtin",
|
||||
"graph" - "list",
|
||||
"graph" - "std_util",
|
||||
"graph" - "set",
|
||||
"getopt" - "mercury_builtin",
|
||||
"getopt" - "list",
|
||||
"getopt" - "std_util",
|
||||
"getopt" - "map",
|
||||
"getopt" - "bool",
|
||||
"getopt" - "char",
|
||||
"float" - "mercury_builtin",
|
||||
"set" - "mercury_builtin",
|
||||
"set" - "list",
|
||||
"set" - "bool",
|
||||
"eqvclass" - "mercury_builtin",
|
||||
"eqvclass" - "list",
|
||||
"eqvclass" - "set",
|
||||
"dir" - "mercury_builtin",
|
||||
"debugger_interface" - "mercury_builtin",
|
||||
"char" - "mercury_builtin",
|
||||
"int" - "mercury_builtin",
|
||||
"bt_array" - "mercury_builtin",
|
||||
"bt_array" - "list",
|
||||
"bt_array" - "int",
|
||||
"bool" - "mercury_builtin",
|
||||
"bool" - "list",
|
||||
"bintree_set" - "mercury_builtin",
|
||||
"bintree_set" - "list",
|
||||
"bintree" - "mercury_builtin",
|
||||
"bintree" - "list",
|
||||
"bintree" - "assoc_list",
|
||||
"map" - "mercury_builtin",
|
||||
"map" - "list",
|
||||
"map" - "assoc_list",
|
||||
"map" - "set",
|
||||
"map" - "tree234",
|
||||
"bimap" - "mercury_builtin",
|
||||
"bimap" - "list",
|
||||
"bimap" - "assoc_list",
|
||||
"bimap" - "map",
|
||||
"benchmarking" - "mercury_builtin",
|
||||
"bag" - "mercury_builtin",
|
||||
"bag" - "list",
|
||||
"bag" - "assoc_list",
|
||||
"assoc_list" - "mercury_builtin",
|
||||
"assoc_list" - "list",
|
||||
"assoc_list" - "std_util",
|
||||
"std_util" - "mercury_builtin",
|
||||
"std_util" - "list",
|
||||
"std_util" - "set",
|
||||
"list" - "mercury_builtin",
|
||||
"list" - "int",
|
||||
"mercury_builtin" - "mercury_builtin",
|
||||
"array" - "mercury_builtin",
|
||||
"array" - "list",
|
||||
"array" - "std_util"]).
|
||||
|
||||
:- end_module rtc_bug.
|
||||
|
||||
Reference in New Issue
Block a user