Prolog "railgun"
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
:- op(700, xfx, in).
:- op(700, xfx, ins).
:- op(700, xfx, #\=).
:- op(700, xfx, #=).
:- op(700, xfx, #<).
:- op(700, xfx, #=<).
:- op(700, xfx, #>).
:- op(700, xfx, #>=).
:- op(700, xfx, ::).
:- op(600, xfx, ..).
:- ensure_loaded(library(sets)).
:- ensure_loaded(library(lists)).
:- ensure_loaded(library(edge/attrvars)).
:- multifile(sys_meta_args/3).
sys_meta_args(between, 3, [e,e,t]).
/**************************************************************/
/* in/2, ins/2 and all_different/1 */
/**************************************************************/
/**
* T in D:
* The predicate delays the goal in D on the term T.
*/
% in(+Term, +Range)
in(T, L..H) :- T = '$ATTR'(V,R), var(V), !,
sys_attr_conc(R, [between(L, H, V)|_]).
in('$ATTR'(T,_), L..H) :- !,
in(T, L..H).
in(T, L..H) :-
between(L, H, T).
% sys_attr_conc(+List, +List)
sys_attr_conc(V, R) :- var(V), !, V = R.
sys_attr_conc([_|L], R) :- sys_attr_conc(L, R).
/**
* L ins D:
* The predicate delays the goal in D on the elements L.
*/
% ins(+List, +Range)
ins([], _).
ins([X|L], D) :-
in(X, D),
ins(L, D).
/**
* all_different(L):
* The predicate delays the goal that all elements of L are different.
*/
% all_different(+List)
all_different([]).
all_different([X|L]) :-
maplist(#\=(X), L),
all_different(L).
/**************************************************************/
/* (#=)/2, (#\=)/2, (#<)/2, (#=<)/2, (#>)/2 and (#>=)/2 */
/**************************************************************/
/**
* S #= T:
* The predicate delays the goal S =:= T on the terms S and T.
*/
% +Term #= +Term
A #= B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C =:= D).
/**
* S #\= T:
* The predicate delays the goal S =\= T on the terms S and T.
*/
% +Term #\= +Term
A #\= B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C =\= D).
/**
* S #< T:
* The predicate delays the goal S < T on the terms S and T.
*/
% +Term #< +Term
A #< B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C < D).
/**
* S #=< T:
* The predicate delays the goal S =< T on the terms S and T.
*/
% +Term #=< +Term
A #=< B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C =< D).
/**
* S #> T:
* The predicate delays the goal S > T on the terms S and T.
*/
% +Term #> +Term
A #> B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C > D).
/**
* S #>= T:
* The predicate delays the goal S >= T on the terms S and T.
*/
% +Term #>= +Term
A #>= B :-
sys_attr_expr(A, C, [], H),
sys_attr_expr(B, D, H, M),
sys_attr_delay(M, C >= D).
% sys_attr_delay(+Map, +Goal)
sys_attr_delay([], G) :- !,
sys_strip_goal(G, F), F.
sys_attr_delay(M, G) :-
sys_attr_post(M, G).
% sys_attr_post(+Map, +Goal)
sys_attr_post([], _).
sys_attr_post(['$ATTR'(_,L)|M], G) :-
sys_attr_conc(L, [G|_]),
sys_attr_post(M, G).
% sys_attr_expr(+Term, -Term, +Map, -Map)
sys_attr_expr(T, (V :: D), M, N) :- T = '$ATTR'(V,R), var(V), !,
sys_attr_range(R, D),
sys_attr_extend(T, M, N).
sys_attr_expr('$ATTR'(T,_), S, M, N) :- !,
sys_attr_expr(T, S, M, N).
sys_attr_expr(-A, R, M, N) :- !,
sys_attr_expr(A, X, M, N),
sys_simp_neg(X, R).
sys_attr_expr(A+B, R, M, N) :- !,
sys_attr_expr(A, X, M, H),
sys_attr_expr(B, Y, H, N),
sys_simp_add(X, Y, R).
sys_attr_expr(A-B, R, M, N) :- !,
sys_attr_expr(A, X, M, H),
sys_attr_expr(B, Y, H, N),
sys_simp_sub(X, Y, R).
sys_attr_expr(A*B, R, M, N) :- !,
sys_attr_expr(A, X, M, H),
sys_attr_expr(B, Y, H, N),
sys_simp_mul(X, Y, R).
sys_attr_expr(T, T, M, M).
% sys_attr_extend(+Term, +Map, -Map)
sys_attr_extend('$ATTR'(V,_), M, M) :- member('$ATTR'(W,_), M), V == W, !.
sys_attr_extend(T, M, [T|M]).
% sys_attr_range(+List, -Range)
sys_attr_range(R, _) :- var(R),
throw(error(resource_error(range_missing), _)).
sys_attr_range([between(L, H, _)|_], L..H) :- !.
sys_attr_range(_, _) :-
throw(error(resource_error(range_missing), _)).
/**************************************************************/
/* labeling/2 */
/**************************************************************/
/**
* labeling(O, L):
* The predicate resolves the elements of L, statically reordered
* accordingly to the option list O. For the available options
* see the documentation.
*/
% labeling(+List, +List)
labeling(O, L) :-
sys_attr_opts(O, v(2,0), v(F,G)),
catch((sys_reorder_plan(L, Q, F), throw(sys_ball(Q))),
sys_ball(U),
sys_reorder_doit(L, U, R)),
sys_label(R, G).
% sys_reorder_plan(+List, -List, +Integer)
sys_reorder_plan([], [], _).
sys_reorder_plan([X|L], [I|R], F) :- X = '$ATTR'(V,U), var(V), !,
sys_attr_score(U, S, F),
sys_attr_best(L, S, 1, 0, I, F),
nth0(I, [X|L], Y, H),
Y = '$ATTR'(*,_),
sys_reorder_plan(H, R, F).
sys_reorder_plan([_|L], R, F) :-
sys_reorder_plan(L, R, F).
% sys_reorder_doit(+List, +List, -List)
sys_reorder_doit([], [], []).
sys_reorder_doit([X|L], [I|Q], [Y|R]) :- X = '$ATTR'(V,_), var(V), !,
nth0(I, [X|L], Y, H),
sys_reorder_doit(H, Q, R).
sys_reorder_doit([_|L], Q, R) :-
sys_reorder_doit(L, Q, R).
/**
* sys_attr_score(L, S, F):
* The predicate succeeds in S with a pair of the number of free variables
* in the constraints, and the negation of the number of constraints
* for the attributed variable X.
*/
% sys_attr_score(+List, -Integer, +Integer)
sys_attr_score(L, S-U, F) :-
term_variables(L, H),
length(H, S),
sys_attr_skim(L, F, 0, U).
% sys_attr_best(+List, +Integer, +Integer, +Integer, -Integer, +Integer)
sys_attr_best([], _, _, I, I, _).
sys_attr_best(['$ATTR'(V,U)|L], S, K, _, O, F) :- var(V),
sys_attr_score(U, T, F), T @=< S, !,
H is K+1,
sys_attr_best(L, T, H, K, O, F).
sys_attr_best([_|L], S, K, I, O, F) :-
H is K+1,
sys_attr_best(L, S, H, I, O, F).
% sys_attr_skim(+List, +Integer, +Integer, -Integer, +Integer)
sys_attr_skim(V, _, U, U) :- var(V), !.
sys_attr_skim([G|L], 2, U, V) :- term_variables(G, R), R \= [], !,
length(R, J),
H is U-1/J,
sys_attr_skim(L, 2, H, V).
sys_attr_skim([G|L], 1, U, V) :- term_variables(G, [_]), !,
H is U-1,
sys_attr_skim(L, 1, H, V).
sys_attr_skim([_|L], F, U, V) :-
sys_attr_skim(L, F, U, V).
/**************************************************************/
/* label/1 */
/**************************************************************/
/**
* label(L):
* The predicate resolves the elements of L, left to right.
*/
% label(+List)
label(L) :-
sys_label(L, 0).
% label(+List, +Integer)
sys_label(L, 1) :- !,
catch((sys_collect_plan(L, P), throw(sys_ball(P))),
sys_ball(V),
sys_collect_doit(L, [], V, R, [])),
% writeq(R), nl,
maplist(deref, L, H),
chan(C),
sys_trans_body(('$SEQ'(nothing,R), send(C,[1|H]); send(C,[0|H])),
nothing, MARK, 1, CONT, []),
catch((cpu_comp_prep(MARK, CONT, 1, COMP), throw(sys_ball(COMP))),
sys_ball(COMP2), create_task(cpu_comp_run(COMP2))),
repeat,
recv(C, [F|H]),
(F = 0 -> !, fail; true).
sys_label(L, _) :-
catch((sys_collect_plan(L, P), throw(sys_ball(P))),
sys_ball(V),
sys_collect_doit(L, [], V, R, [])),
% writeq(R), nl,
sys_encode_body(R, S, []),
'$SEQ'(nothing, S).
% sys_collect_plan(+List, -List)
sys_collect_plan([], []).
sys_collect_plan([X|R], [Q|P]) :- X = '$ATTR'(V,L), var(V), !,
sys_filter_plan(L, 0, Q),
X = '$ATTR'(*,_),
sys_collect_plan(R, P).
sys_collect_plan([_|L], P) :-
sys_collect_plan(L, P).
% sys_filter_plan(+List, +Integer, -List)
sys_filter_plan(V, _, []) :- var(V), !.
sys_filter_plan([G|L], K, [I|Q]) :- term_variables(G, R), R \== [], !,
(R = [_] -> I = K; I is (-K)-1),
J is K+1,
sys_filter_plan(L, J, Q).
sys_filter_plan([_|L], K, Q) :-
J is K+1,
sys_filter_plan(L, J, Q).
% sys_collect_doit(+List, +List, +List, -List, +List)
sys_collect_doit([], _, []) --> [].
sys_collect_doit([X|R], H, [Q|S]) --> {X = '$ATTR'(V,L), var(V)}, !,
sys_filter_bound(Q, P, V, H, Z, L, M),
sys_filter_doit(P, Z, K, M),
sys_collect_doit(R, K, S).
sys_collect_doit([_|L], H, P) -->
sys_collect_doit(L, H, P).
% sys_filter_bound(List, -List, +Var, +List, +List, +List, -List, -List, +List)
sys_filter_bound([], [], _, H, H, L, L) --> [].
sys_filter_bound([I|Q], P, V, H, K, [A|L], S) --> {I >= 0,
nth0(I, [A|L], G)}, sys_attr_crisp(G, V, H, Z, F), !,
{sys_attr_fuse(F, A, B)},
sys_filter_bound(Q, P, V, Z, K, [B|L], S).
sys_filter_bound([I|Q], P, V, H, K, [A|L], S) --> {I < 0,
J is (-I)-1, nth0(J, [A|L], G)}, sys_attr_coarse(G, V, H, Z, F), !,
{sys_attr_fuse(F, A, B)},
sys_filter_bound(Q, P, V, Z, K, [B|L], S).
sys_filter_bound([I|Q], [I|P], V, H, K, L, S) -->
sys_filter_bound(Q, P, V, H, K, L, S).
% sys_filter_doit(+List, +List, +List, +List, -List, +List)
sys_filter_doit([], H, H, _) --> [].
sys_filter_doit([I|Q], H, K, L) --> {I >= 0}, !,
{nth0(I, L, G)},
sys_attr_goal(G, H, Z),
sys_filter_doit(Q, Z, K, L).
sys_filter_doit([I|Q], H, K, L) -->
{J is (-I)-1, nth0(J, L, G)},
sys_attr_test(G, H),
sys_filter_doit(Q, H, K, L).
% sys_attr_fuse(+Goal, +Goal, -Goal)
sys_attr_fuse(between(C, D, X),
between(A, B, X),
between(P, Q, X)) :-
sys_simp_max(A, C, P),
sys_simp_min(B, D, Q).
sys_attr_fuse(true, G, G).
/***********************************************************/
/* Indexicals */
/***********************************************************/
% sys_attr_crisp(+Goal, +Var, +List, +List, -Goal, -List, +List)
sys_attr_crisp(A =:= B, W, H, Z, G2) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_index(W, V, H, Z),
{G2 = true};
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_index(W, K, H, Z),
{G2 = true};
{fail}).
sys_attr_crisp(A =< B, W, H, H, G2) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
{G2 = between(-0rInf, V, W)};
{U = -1} ->
{sys_simp_neg(V, K),
G2 = between(K, 0rInf, W)};
{fail}).
sys_attr_crisp(A < B, W, H, H, G2) -->
{sys_attr_linear(A+1, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
{G2 = between(-0rInf, V, W)};
{U = -1} ->
{sys_simp_neg(V, K),
G2 = between(K, 0rInf, W)};
{fail}).
sys_attr_crisp(B >= A, W, H, H, G2) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
{G2 = between(-0rInf, V, W)};
{U = -1} ->
{sys_simp_neg(V, K),
G2 = between(K, 0rInf, W)};
{fail}).
sys_attr_crisp(B > A, W, H, H, G2) -->
{sys_attr_linear(A+1, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
{G2 = between(-0rInf, V, W)};
{U = -1} ->
{sys_simp_neg(V, K),
G2 = between(K, 0rInf, W)};
{fail}).
% sys_attr_coarse(+Goal, +Var, +List, -List, -Goal, -List, +List)
sys_attr_coarse(A =:= B, W, H, Z, G) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_inter(V, H, E),
sys_inter_bound(E, W, H, Z, G);
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_inter(K, H, E),
sys_inter_bound(E, W, H, Z, G);
{fail}).
sys_attr_coarse(A =< B, W, H, H, G) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_inter(V, H, E),
{sys_inter_lower(E, W, G)};
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_inter(K, H, E),
{sys_inter_upper(E, W, G)};
{fail}).
sys_attr_coarse(A < B, W, H, H, G) -->
{sys_attr_linear(A+1, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_inter(V, H, E),
{sys_inter_lower(E, W, G)};
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_inter(K, H, E),
{sys_inter_upper(E, W, G)};
{fail}).
sys_attr_coarse(B >= A, W, H, H, G) -->
{sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_inter(V, H, E),
{sys_inter_lower(E, W, G)};
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_inter(K, H, E),
{sys_inter_upper(E, W, G)};
{fail}).
sys_attr_coarse(B > A, W, H, H, G) -->
{sys_attr_linear(A+1, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(S, Q, V)},
({U = 1} ->
sys_attr_inter(V, H, E),
{sys_inter_lower(E, W, G)};
{U = -1} ->
{sys_simp_neg(V, K)},
sys_attr_inter(K, H, E),
{sys_inter_upper(E, W, G)};
{fail}).
% sys_inter_bound(+Pair, +Var, +List, -List, -Goal)
sys_inter_bound(L..H, X, Z, Z, between(L, H, X)) --> !.
sys_inter_bound(P, X, H, Z, true) -->
sys_attr_index(X, P, H, Z).
% sys_inter_lower(+Pair, +Var, -Goal)
sys_inter_lower(_..H, X, between(-0rInf, H, X)) :- !.
sys_inter_lower(P, X, between(-0rInf, P, X)).
% sys_inter_upper(+Pair, +Var, -Goal)
sys_inter_upper(L.._, X, between(L, 0rInf, X)) :- !.
sys_inter_upper(P, X, between(P, 0rInf, X)).
% sys_attr_index(+Var, +Expr, +List, -List, -List, +List)
sys_attr_index(V, E, H, H) --> {occurs_check(V, H)}, !,
sys_attr_emit((V:: -0rInf..0rInf) =:= E).
sys_attr_index(V, E, H, [V|H]) -->
sys_attr_emit(V is E).
/***********************************************************/
/* Goals */
/***********************************************************/
% sys_attr_goal(+Goal, +List, -List, -List, +List)
sys_attr_goal(between(A, B, X), H, H) --> {occurs_check(X, H)}, !,
sys_attr_emit(A =< (X:: -0rInf..0rInf)),
sys_attr_emit((X:: -0rInf..0rInf) =< B).
sys_attr_goal(between(A, B, X), H, [X|H]) --> !,
sys_attr_set(P, A),
sys_attr_set(Q, B),
sys_attr_emit(between(P, Q, X)).
sys_attr_goal(G, H, H) -->
sys_attr_emit(G).
% sys_attr_set(-Expr, +Expr)
sys_attr_set(T, T) --> {T = (_::_)}, !.
sys_attr_set(T, T) --> {integer(T)}, !.
sys_attr_set(V:: -0rInf..0rInf, E) -->
sys_attr_emit(V is E).
% sys_attr_emit(+Goal, -List, +List)
sys_attr_emit(G) -->
{sys_strip_goal(G, A)},
[A].
/***********************************************************/
/* Tests */
/***********************************************************/
% sys_attr_test(+Goal, +List, -List, +List)
sys_attr_test(A =:= B, H) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_eq(C, D).
sys_attr_test(A =< B, H) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_lq(C, D).
sys_attr_test(A < B, H) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_ls(C, D).
sys_attr_test(A >= B, H) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_gq(C, D).
sys_attr_test(A > B, H) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_gr(C, D).
sys_attr_test(_, _) --> [].
% sys_inter_eq(+Pair, +Pair, -List, +List)
sys_inter_eq(L1..H1, L2..H2) --> !,
sys_attr_emit(L1 =< H2),
sys_attr_emit(L2 =< H1).
sys_inter_eq(L1..H1, P2) --> !, sys_attr_set(V, P2),
sys_attr_emit(L1 =< V),
sys_attr_emit(V =< H1).
sys_inter_eq(P1, L2..H2) --> !, sys_attr_set(U, P1),
sys_attr_emit(U =< H2),
sys_attr_emit(L2 =< U).
sys_inter_eq(P1, P2) -->
sys_attr_emit(P1 =:= P2).
% sys_inter_lq(+Pair, +Pair, -List, +List)
sys_inter_lq(L1.._, _..H2) --> !,
sys_attr_emit(L1 =< H2).
sys_inter_lq(L1.._, P2) --> !,
sys_attr_emit(L1 =< P2).
sys_inter_lq(P1, _..H2) --> !,
sys_attr_emit(P1 =< H2).
sys_inter_lq(P1, P2) -->
sys_attr_emit(P1 =< P2).
% sys_inter_ls(+Pair, +Pair, -List, +List)
sys_inter_ls(L1.._, _..H2) --> !,
sys_attr_emit(L1 < H2).
sys_inter_ls(L1.._, P2) --> !,
sys_attr_emit(L1 < P2).
sys_inter_ls(P1, _..H2) --> !,
sys_attr_emit(P1 < H2).
sys_inter_ls(P1, P2) -->
sys_attr_emit(P1 < P2).
% sys_inter_gq(+Pair, +Pair, -List, +List)
sys_inter_gq(_..H1, L2.._) --> !,
sys_attr_emit(H1 >= L2).
sys_inter_gq(_..H1, P2) --> !,
sys_attr_emit(H1 >= P2).
sys_inter_gq(P1, L2.._) --> !,
sys_attr_emit(P1 >= L2).
sys_inter_gq(P1, P2) -->
sys_attr_emit(P1 >= P2).
% sys_inter_gr(+Pair, +Pair, -List, +List)
sys_inter_gr(_..H1, L2.._) --> !,
sys_attr_emit(H1 > L2).
sys_inter_gr(_..H1, P2) --> !,
sys_attr_emit(H1 > P2).
sys_inter_gr(P1, L2.._) --> !,
sys_attr_emit(P1 > L2).
sys_inter_gr(P1, P2) -->
sys_attr_emit(P1 > P2).
/***********************************************************/
/* Interval Arithmetic */
/***********************************************************/
% sys_attr_inter(+Expr, +List, -Pair, -List, +List)
sys_attr_inter(T, H, T) --> {T = (V :: _), occurs_check(V, H)}, !.
sys_attr_inter((_ :: D), _, D) --> !.
sys_attr_inter(-A, H, R) --> !,
sys_attr_inter(A, H, B),
sys_inter_neg(B, R).
sys_attr_inter(A+B, H, R) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_add(C, D, R).
sys_attr_inter(A-B, H, R) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_sub(C, D, R).
sys_attr_inter(A*B, H, R) --> !,
sys_attr_inter(A, H, C),
sys_attr_inter(B, H, D),
sys_inter_mul(C, D, R).
sys_attr_inter(T, _, T) --> [].
% sys_inter_neg(+Pair, -Pair, -List, +List)
sys_inter_neg(L..H, X..Y) --> !,
{sys_simp_neg(H, X), sys_simp_neg(L, Y)}.
sys_inter_neg(P, X) -->
{sys_simp_neg(P, X)}.
% sys_inter_add(+Pair, +Pair, -Pair, -List, +List)
sys_inter_add(L1..H1, L2..H2, X..Y) --> !,
{sys_simp_add(L1, L2, X), sys_simp_add(H1, H2, Y)}.
sys_inter_add(L1..H1, P2, X..Y) --> !,
sys_attr_set(V, P2),
{sys_simp_add(L1, V, X), sys_simp_add(H1, V, Y)}.
sys_inter_add(P1, L2..H2, X..Y) --> !,
sys_attr_set(U, P1),
{sys_simp_add(U, L2, X), sys_simp_add(U, H2, Y)}.
sys_inter_add(P1, P2, X) -->
{sys_simp_add(P1, P2, X)}.
% sys_inter_sub(+Pair, +Pair, -Pair, -List, +List)
sys_inter_sub(L1..H1, L2..H2, X..Y) --> !,
{sys_simp_sub(L1, H2, X), sys_simp_sub(H1, L2, Y)}.
sys_inter_sub(L1..H1, P2, X..Y) --> !,
sys_attr_set(V, P2),
{sys_simp_sub(L1, V, X), sys_simp_sub(H1, V, Y)}.
sys_inter_sub(P1, L2..H2, X..Y) --> !,
sys_attr_set(U, P1),
{sys_simp_sub(U, H2, X), sys_simp_sub(U, L2, Y)}.
sys_inter_sub(P1, P2, X) -->
{sys_simp_sub(P1, P2, X)}.
% sys_inter_mul(+Pair, +Pair, -Pair, -List, +List)
sys_inter_mul(L1..H1, L2..H2, X..Y) --> !,
sys_attr_set(U1, L1), sys_attr_set(U2, H1),
sys_attr_set(V1, L2), sys_attr_set(V2, H2),
{sys_simp_mul(U1, V1, J11), sys_simp_mul(U1, V2, J12),
sys_simp_mul(U2, V1, J21), sys_simp_mul(U2, V2, J22)},
sys_attr_set(W11, J11), sys_attr_set(W12, J12),
sys_attr_set(W21, J21), sys_attr_set(W22, J22),
{sys_simp_min(W11, W12, X1), sys_simp_max(W11, W12, Y1),
sys_simp_min(W21, W22, X2), sys_simp_max(W21, W22, Y2),
sys_simp_min(X1, X2, X), sys_simp_max(Y1, Y2, Y)}.
sys_inter_mul(L1..H1, P2, X..Y) --> !,
sys_attr_set(V, P2),
{sys_simp_mul(L1, V, J1), sys_simp_mul(H1, V, J2)},
sys_attr_set(W1, J1), sys_attr_set(W2, J2),
{sys_simp_min(W1, W2, X), sys_simp_max(W1, W2, Y)}.
sys_inter_mul(P1, L2..H2, X..Y) --> !,
sys_attr_set(U, P1),
{sys_simp_mul(U, L2, J1), sys_simp_mul(U, H2, J2)},
sys_attr_set(W1, J1), sys_attr_set(W2, J2),
{sys_simp_min(W1, W2, X), sys_simp_max(W1, W2, Y)}.
sys_inter_mul(P1, P2, X) -->
{sys_simp_mul(P1, P2, X)}.
/***********************************************************/
/* Linear Forms */
/***********************************************************/
% sys_attr_linear(+Expr, +Var, -Pair)
sys_attr_linear((V :: _), W, (1,0)) :- W == V, !.
sys_attr_linear(T, _, (0,T)) :- T = (_ :: _), !.
sys_attr_linear(-A, W, (R,S)) :- !,
sys_attr_linear(A, W, (P,Q)),
sys_simp_neg(P, R),
sys_simp_neg(Q, S).
sys_attr_linear(A+B, W, (U,V)) :- !,
sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_add(P, R, U),
sys_simp_add(Q, S, V).
sys_attr_linear(A-B, W, (U,V)) :- !,
sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
sys_simp_sub(P, R, U),
sys_simp_sub(Q, S, V).
sys_attr_linear(A*B, W, (U,V)) :- !,
sys_attr_linear(A, W, (P,Q)),
sys_attr_linear(B, W, (R,S)),
(P = 0 ->
sys_simp_mul(Q, R, U),
sys_simp_mul(Q, S, V);
R = 0 ->
sys_simp_mul(P, S, U),
sys_simp_mul(Q, S, V);
fail).
sys_attr_linear(T, _, (0,T)).
/***********************************************************/
/* Simplify Forms */
/***********************************************************/
% sys_simp_neg(+Expr, -Expr)
sys_simp_neg(A, B) :- integer(A), !, B is -A.
sys_simp_neg(-X, X) :- !.
sys_simp_neg(X-Y, R+Y) :- !, sys_simp_neg(X, R).
sys_simp_neg(X+Y, R-Y) :- !, sys_simp_neg(X, R).
sys_simp_neg(X, -X).
% sys_simp_add(+Expr, +Expr, -Expr)
sys_simp_add(A, B, C) :- integer(A), integer(B), !, C is A+B.
sys_simp_add(0, Y, Y) :- !.
sys_simp_add(X, 0, X) :- !.
sys_simp_add(X, Y+Z, R) :- !, sys_simp_add(X, Y, H), sys_simp_add(H, Z, R).
sys_simp_add(X, Y-Z, R) :- !, sys_simp_add(X, Y, H), sys_simp_sub(H, Z, R).
sys_simp_add(X, -Y, X-Y) :- !.
sys_simp_add(X, Y, X+Y).
% sys_simp_sub(+Expr, +Expr, -Expr)
sys_simp_sub(A, B, C) :- integer(A), integer(B), !, C is A-B.
sys_simp_sub(0, Y, R) :- !, sys_simp_neg(Y, R).
sys_simp_sub(X, 0, X) :- !.
sys_simp_sub(X, Y+Z, R) :- !, sys_simp_sub(X, Y, H), sys_simp_sub(H, Z, R).
sys_simp_sub(X, Y-Z, R) :- !, sys_simp_sub(X, Y, H), sys_simp_add(H, Z, R).
sys_simp_sub(X, -Y, X+Y) :- !.
sys_simp_sub(X, Y, X-Y).
% sys_simp_mul(+Expr, +Expr, -Expr)
sys_simp_mul(A, B, C) :- integer(A), integer(B), !, C is A*B.
sys_simp_mul(0, _, 0) :- !.
sys_simp_mul(_, 0, 0) :- !.
sys_simp_mul(1, Y, Y) :- !.
sys_simp_mul(X, 1, X) :- !.
sys_simp_mul(-1, Y, R) :- !, sys_simp_neg(Y, R).
sys_simp_mul(X, -1, R) :- !, sys_simp_neg(X, R).
sys_simp_mul(X, Y*Z, R) :- !, sys_simp_mul(X, Y, H), sys_simp_mul(H, Z, R).
sys_simp_mul(-X, Y, R) :- !, sys_simp_mul(X, Y, H), sys_simp_neg(H, R).
sys_simp_mul(X, -Y, R) :- !, sys_simp_mul(X, Y, H), sys_simp_neg(H, R).
sys_simp_mul(X, Y, X*Y).
% sys_simp_min(+Expr, +Expr, -Expr)
sys_simp_min(A, B, C) :- integer(A), integer(B), !, C is min(A,B).
sys_simp_min(0rInf, Y, Y) :- !.
sys_simp_min(X, 0rInf, X) :- !.
sys_simp_min(X, Y, min(X,Y)).
% sys_simp_max(+Expr, +Expr, -Expr)
sys_simp_max(A, B, C) :- integer(A), integer(B), !, C is max(A,B).
sys_simp_max(-0rInf, Y, Y) :- !.
sys_simp_max(X, -0rInf, X) :- !.
sys_simp_max(X, Y, max(X,Y)).
/***********************************************************/
/* Erase Ranges */
/***********************************************************/
/**
* sys_strip_goal(A, B):
* The predicate succeeds in B with the range erasure of A.
*/
% sys_strip_goal(+Callable, -Callable)
sys_strip_goal(G, H) :- functor(G, F, N),
sys_meta_args(F, N, M), !,
sys_strip_meta(M, G, H).
sys_strip_goal(G, G).
% sys_strip_meta(+List, +Callable, -Callable)
sys_strip_meta(M, C, G) :-
C =.. [F|L],
sys_strip_args(M, L, R),
G =.. [F|R].
% sys_strip_args(+List, +List, -List)
sys_strip_args([], [], []).
sys_strip_args([T|M], [X|L], [Y|R]) :-
sys_strip_arg(T, X, Y),
sys_strip_args(M, L, R).
% sys_strip_arg(+Atom, +Term, -Term)
sys_strip_arg(t, X, X).
sys_strip_arg(e, X, Y) :- sys_strip_expr(X, Y).
% sys_strip_expr(+Expr, -Expr)
sys_strip_expr((V :: _), V) :- !.
sys_strip_expr(C, G) :- compound(C), !,
C =.. [F|L],
sys_strip_exprs(L, R),
G =.. [F|R].
sys_strip_expr(T, T).
% sys_strip_exprs(+List, -List)
sys_strip_exprs([], []).
sys_strip_exprs([X|L], [Y|R]) :-
sys_strip_expr(X, Y),
sys_strip_exprs(L, R).
/***************************************************************/
/* Decode Options */
/***************************************************************/
% sys_attr_opts(+List, +Pair, -Pair)
sys_attr_opts(V, _, _) :- var(V),
throw(error(instantiation_error,_)).
sys_attr_opts([X|L], I, O) :- !,
sys_attr_opt(X, I, H),
sys_attr_opts(L, H, O).
sys_attr_opts([], I, I) :- !.
sys_attr_opts(L, _, _) :-
throw(error(type_error(list,L),_)).
% sys_attr_opt(+Term, +Pair, -Pair)
sys_attr_opt(V, _, _) :- var(V),
throw(error(instantiation_error,_)).
sys_attr_opt(zero, v(_,Y), v(0,Y)) :- !.
sys_attr_opt(constr, v(_,Y), v(1,Y)) :- !.
sys_attr_opt(plausi, v(_,Y), v(2,Y)) :- !.
sys_attr_opt(doge, v(X,_), v(X,0)) :- !.
sys_attr_opt(cpu, v(X,_), v(X,1)) :- !.
sys_attr_opt(gpu, v(X,_), v(X,2)) :- !.
sys_attr_opt(O, _, _) :-
throw(error(domain_error(attr_opt,O),_)).
/****************************************************************/
/* Error Texts */
/****************************************************************/
% strings(+Atom, +Atom, -Atom)
:- multifile(strings/3).
strings('domain_error.attr_opt', de, 'Wertzuweisungsoption erwartet, gefunden ~q.').
strings('resource_error.range_missing', de, 'Domain fehlt.').
strings('domain_error.attr_opt', '', 'Labeling option expected, found ~q.').
strings('resource_error.range_missing', '', 'Domain missing').