413 lines
9.0 KiB
Prolog
413 lines
9.0 KiB
Prolog
%% -*- mode: prolog-*-
|
|
%% vim: set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
|
|
%% Follows 'Coding guidelines for Prolog' - Theory and Practice of Logic Programming
|
|
%% https://doi.org/10.1017/S1471068411000391
|
|
|
|
%% Import the Constraint Logic Programming over Finite Domains lybrary
|
|
%% Essentially, this library improves the way Prolog deals with integers,
|
|
%% allowing more predicates to be reversible.
|
|
%% For instance, number(N) is always false, which prevents the
|
|
%% reversing of a predicate.
|
|
:- use_module(library(clpfd)).
|
|
|
|
%% polynomial_variable_list(-List) is det
|
|
%
|
|
% List of possible polynomial variables
|
|
%
|
|
polynomial_variable_list([x, y, z]).
|
|
|
|
%% polynomial_variable(?X:atom) is det
|
|
%
|
|
% Returns true if X is a polynomial variable, false otherwise.
|
|
%
|
|
polynomial_variable(X) :-
|
|
polynomial_variable_list(V),
|
|
member(X, V).
|
|
%% Tests:
|
|
%% ?- polynomial_variable(x).
|
|
%@ true .
|
|
%% ?- polynomial_variable(a).
|
|
%@ false.
|
|
|
|
%% power(+X:atom) is semidet
|
|
%
|
|
% Returns true if X is a power term, false otherwise.
|
|
%
|
|
power(P^N) :-
|
|
(
|
|
zcompare((<), 0, N),
|
|
polynomial_variable(P)
|
|
;
|
|
fail
|
|
).
|
|
power(X) :-
|
|
polynomial_variable(X).
|
|
%% Tests:
|
|
%% ?- power(x).
|
|
%@ true .
|
|
%% ?- power(x^1).
|
|
%@ true .
|
|
%% ?- power(x^3).
|
|
%@ true .
|
|
%% ?- power(x^(-3)).
|
|
%@ error.
|
|
%% ?- power(X).
|
|
%@ X = x ;
|
|
%@ X = y ;
|
|
%@ X = z.
|
|
|
|
%% term(+N:atom) is det
|
|
%
|
|
% Returns true if N is a term, false otherwise.
|
|
%
|
|
term(N) :-
|
|
number(N).
|
|
term(X) :-
|
|
power(X).
|
|
term(L * R) :-
|
|
term(L),
|
|
term(R).
|
|
%% Tests:
|
|
%% ?- term(2*x^3).
|
|
%@ true .
|
|
%% ?- term(x^(-3)).
|
|
%@ false.
|
|
%% ?- term((-3)*x^2).
|
|
%@ true .
|
|
|
|
%% is_term_valid_in_predicate(+T, +F) is det
|
|
%
|
|
% Returns true if valid Term, fails with UI message otherwise.
|
|
% The fail message reports which Term is invalid and in which
|
|
% predicate the problem ocurred.
|
|
%
|
|
is_term_valid_in_predicate(T, F) :-
|
|
(
|
|
term(T)
|
|
;
|
|
write("Invalid term in "),
|
|
write(F),
|
|
write(": "),
|
|
write(T),
|
|
fail
|
|
).
|
|
%% Tests:
|
|
%% ?- is_term_valid_in_predicate(1, "Chuck Norris").
|
|
%@ true .
|
|
|
|
%% polynomial(+M:atom) is det
|
|
%
|
|
% Returns true if polynomial, false otherwise.
|
|
%
|
|
polynomial(M) :-
|
|
term(M).
|
|
polynomial(L + R) :-
|
|
polynomial(L),
|
|
term(R).
|
|
%% Tests:
|
|
%% ?- polynomial(x).
|
|
%@ true .
|
|
%% ?- polynomial(x^3).
|
|
%@ true .
|
|
%% ?- polynomial(3*x^7).
|
|
%@ true .
|
|
%% ?- polynomial(2 + 3*x + 4*x*y^3).
|
|
%@ true .
|
|
|
|
%% power_to_canon(+T:atom, -T^N:atom) is det
|
|
%
|
|
% Returns a canon power term.
|
|
%
|
|
power_to_canon(T^N, T^N) :-
|
|
polynomial_variable(T),
|
|
%% N \= 1.
|
|
(
|
|
zcompare(=, 1, N)
|
|
;
|
|
true
|
|
).
|
|
power_to_canon(T, T^1) :-
|
|
polynomial_variable(T).
|
|
%% Tests:
|
|
%% ?- power_to_canon(x, X).
|
|
%@ X = x^1 .
|
|
%% ?- power_to_canon(X, x^1).
|
|
%@ X = x .
|
|
%@ X = x .
|
|
%% ?- power_to_canon(X, x^4).
|
|
%@ X = x^4 .
|
|
|
|
%% term_to_list(?T, ?List) is det
|
|
%
|
|
% Converts a term to a list and vice versa.
|
|
% Can verify if term and list are compatible.
|
|
%
|
|
term_to_list(L * N, [N | TS]) :-
|
|
number(N),
|
|
term_to_list(L, TS).
|
|
term_to_list(L * P, [P2 | TS]) :-
|
|
power(P),
|
|
power_to_canon(P, P2),
|
|
term_to_list(L, TS).
|
|
term_to_list(N, [N]) :-
|
|
number(N).
|
|
term_to_list(P, [P2]) :-
|
|
power(P),
|
|
power_to_canon(P, P2).
|
|
%% Tests:
|
|
%% ?- term_to_list(1*2*y*z*23*x*y*x^3*x, X).
|
|
%@ X = [x^1, x^3, y^1, x^1, 23, z^1, y^1, 2, 1] .
|
|
%% ?- term_to_list(X, [y^1, x^1]).
|
|
%@ X = x*y .
|
|
%% ?- term_to_list(X, [x^4]).
|
|
%@ false.
|
|
%@ false.
|
|
%@ X = x^4 .
|
|
%% ?- term_to_list(X, [y^6, z^2, x^4]).
|
|
%@ X = x^4*z^2*y^6 .
|
|
|
|
%% simplify_term(+Term_In:term, ?Term_Out:term) is det
|
|
%
|
|
% Simplifies a term.
|
|
%
|
|
simplify_term(Term_In, Term_Out) :-
|
|
term_to_list(Term_In, L),
|
|
sort(0, @=<, L, L2),
|
|
(
|
|
member(0, L2),
|
|
Term_Out = 0
|
|
;
|
|
exclude(==(1), L2, L3),
|
|
join_like_terms(L3, L4),
|
|
sort(0, @>=, L4, L5),
|
|
term_to_list(Term_Out, L5)
|
|
),
|
|
% First result is always the most simplified form.
|
|
!.
|
|
%% Tests:
|
|
%% ?- simplify_term(2*y*z*x^3*x, X).
|
|
%@ X = 2*x^4*y*z.
|
|
%% ?- simplify_term(1*y*z*x^3*x, X).
|
|
%@ X = x^4*y*z.
|
|
%% ?- simplify_term(0*y*z*x^3*x, X).
|
|
%@ X = 0.
|
|
%% ?- simplify_term(6*y*z*7*x*y*x^3*x, X).
|
|
%@ X = 42*x^2*x^3*y^2*z.
|
|
|
|
%% join_like_terms(+List, -List)
|
|
%
|
|
% Combine powers of the same variable in the given list
|
|
%
|
|
join_like_terms([P1, P2 | L], [B^N | L2]) :-
|
|
power(P1),
|
|
power(P2),
|
|
B^N1 = P1,
|
|
B^N2 = P2,
|
|
%% B1 == B2, % Wasn't working before..?
|
|
N is N1 + N2,
|
|
join_like_terms(L, L2).
|
|
join_like_terms([N1, N2 | L], [N | L2]) :-
|
|
number(N1),
|
|
number(N2),
|
|
N is N1 * N2,
|
|
join_like_terms(L, L2).
|
|
join_like_terms([X | L], [X | L2]) :-
|
|
join_like_terms(L, L2).
|
|
join_like_terms([], []).
|
|
%% Tests:
|
|
%% ?- join_like_terms([2, 3, x^1, x^2], T).
|
|
%@ T = [6, x^3].
|
|
%@ T = [6, x^3].
|
|
%% ?- join_like_terms([2, 3, x^1, x^2, y^1, y^6], T).
|
|
%@ T = [6, x^3, y^7].
|
|
%@ T = [6, x^3, y^7].
|
|
|
|
%% simplify_polynomial(+P:atom, -P2:atom) is det
|
|
%
|
|
% Simplifies a polynomial.
|
|
% TODO: not everything is a +, there are -
|
|
%
|
|
simplify_polynomial(M, M2) :-
|
|
%% Are we dealing with a valid term?
|
|
%is_term_valid_in_predicate(M, "simplify_polynomial(M, M2)"),
|
|
term(M),
|
|
%% If so, simplify it.
|
|
simplify_term(M, M2),
|
|
!.
|
|
simplify_polynomial(P + 0, P) :-
|
|
%% Ensure valid term
|
|
%is_term_valid_in_predicate(P, "simplify_polynomial(P + 0, P)"),
|
|
term(P),
|
|
!.
|
|
simplify_polynomial(0 + P, P) :-
|
|
%% Ensure valid term
|
|
%is_term_valid_in_predicate(P, "simplify_polynomial(0 + P, P)"),
|
|
term(P),
|
|
!.
|
|
simplify_polynomial(P + M, P2 + M2) :-
|
|
simplify_polynomial(P, P2),
|
|
simplify_term(M, M2).
|
|
simplify_polynomial(P + M, P2 + M3) :-
|
|
monomial_parts(M, _, XExp),
|
|
delete_monomial(P, XExp, M2, P2),
|
|
!,
|
|
add_monomial(M, M2, M3).
|
|
simplify_polynomial(P + M, P2 + M2) :-
|
|
simplify_polynomial(P, P2),
|
|
simplify_term(M, M2).
|
|
%% Tests:
|
|
%% ?- simplify_polynomial(1, 1).
|
|
%@ Invalid term in simplify_polynomial(M, M2): 1
|
|
%@ false.
|
|
|
|
|
|
%% simplify_polynomial_list(+L1,-L3) is det
|
|
%
|
|
% Simplifies a list of polynomials
|
|
%
|
|
simplify_polynomial_list([L1], L3) :-
|
|
simplify_polynomial(L1, L2),
|
|
L3 = [L2].
|
|
simplify_polynomial_list([L1|L2],L3) :-
|
|
simplify_polynomial(L1, P1),
|
|
simplify_polynomial_list(L2, P2),
|
|
L3 = [P1|P2],
|
|
% There is nothing further to compute at this point
|
|
!.
|
|
|
|
%% polynomial_to_list(+P:polynomial, -L:List)
|
|
%
|
|
% Converts a polynomial in a list.
|
|
% TODO: not everything is a +, there are -
|
|
%
|
|
polynomial_to_list(T1 + T2, L) :-
|
|
polynomial_to_list(T1, L1),
|
|
L = [T2|L1],
|
|
% The others computations are semantically meaningless
|
|
!.
|
|
polynomial_to_list(P, L) :-
|
|
L = [P].
|
|
%% Tests:
|
|
%%?- polynomial_to_list(2*x^2+5+y*2, S).
|
|
%@S = [y*2, 5, 2*x^2].
|
|
|
|
%% list_to_polynomial(+P:polynomial, -L:List)
|
|
%
|
|
% Converts a list in a polynomial.
|
|
% TODO: not everything is a +, there are -
|
|
%
|
|
list_to_polynomial([T1|T2], P) :-
|
|
list_to_polynomial(T2, L1),
|
|
(
|
|
not(L1 = []),
|
|
P = L1+T1
|
|
;
|
|
P = T1
|
|
),
|
|
% The others computations are semantically meaningless
|
|
!.
|
|
list_to_polynomial(T, P) :-
|
|
P = T.
|
|
%% Tests:
|
|
%% TODO
|
|
|
|
%% append_two_atoms_with_star(+V1, +V2, -R) is det
|
|
%
|
|
% Returns R = V1 * V2
|
|
%
|
|
append_two_atoms_with_star(V1, V2, R) :-
|
|
% Convert term V2 into a string V3
|
|
term_string(V2, V3),
|
|
% Concat atom V1 with * into a compound V4
|
|
atom_concat(V1, *, V4),
|
|
% Concat atom V4 with V3 into a compound S
|
|
atom_concat(V4, V3, S),
|
|
% Convert compound S into a term R
|
|
term_string(R, S).
|
|
%% Tests:
|
|
% ?- append_two_atoms_with_star(2, x^2, R).
|
|
%@ R = 2*x^2.
|
|
%@ R = 2*x^2.
|
|
%@ R = 2*3.
|
|
|
|
%% scale_polynomial(+P:polynomial,+C:constant,-S:polynomial) is det
|
|
%
|
|
% Scales a polynomial with a constant
|
|
%
|
|
scale_polynomial(P, C, S) :-
|
|
polynomial_to_list(P, L),
|
|
maplist(append_two_atoms_with_star(C), L, L2),
|
|
list_to_polynomial(L2, S).
|
|
%simplify_polynomial(S1, S).
|
|
%% Tests:
|
|
%% ?- scale_polynomial(3*x^2, 2, S).
|
|
%@ S = 2*3*x^2.
|
|
%@ S = 2*(3*x^2).
|
|
|
|
%% monomial_parts(X, Y, Z)
|
|
%
|
|
% TODO Maybe remove
|
|
% Separate monomial into it's parts. Given K*X^N, gives K and N
|
|
%
|
|
monomial_parts(X, 1, X) :-
|
|
power(X),
|
|
!.
|
|
monomial_parts(X^N, 1, X^N) :-
|
|
power(X^N),
|
|
!.
|
|
monomial_parts(K * M, K, M) :-
|
|
number(K),
|
|
!.
|
|
monomial_parts(K, K, indep) :-
|
|
number(K),
|
|
!.
|
|
|
|
|
|
delete_monomial(M, X, M, 0) :-
|
|
term(M),
|
|
monomial_parts(M, _, X),
|
|
!.
|
|
delete_monomial(M + M2, X, M, M2) :-
|
|
term(M2),
|
|
term(M),
|
|
monomial_parts(M, _, X),
|
|
!.
|
|
delete_monomial(P + M, X, M, P) :-
|
|
term(M),
|
|
monomial_parts(M, _, X),
|
|
!.
|
|
delete_monomial(P + M2, X, M, P2 + M2) :-
|
|
delete_monomial(P, X, M, P2).
|
|
|
|
add_monomial(K1, K2, K3) :-
|
|
number(K1),
|
|
number(K2), !,
|
|
K3 is K1 + K2.
|
|
add_monomial(M1, M2, M3) :-
|
|
monomial_parts(M1, K1, XExp),
|
|
monomial_parts(M2, K2, XExp),
|
|
K3 is K1 + K2,
|
|
p_aux_add_monomial(K3, XExp, M3).
|
|
|
|
p_aux_add_monomial(K, indep, K) :-
|
|
!.
|
|
p_aux_add_monomial(0, _, 0) :-
|
|
!.
|
|
p_aux_add_monomial(1, XExp, XExp) :-
|
|
!.
|
|
p_aux_add_monomial(K, XExp, K * XExp).
|
|
|
|
closure_simplify_polynomial(P, P) :-
|
|
simplify_polynomial(P, P2),
|
|
P==P2,
|
|
!.
|
|
closure_simplify_polynomial(P, P3) :-
|
|
simplify_polynomial(P, P2),
|
|
closure_simplify_polynomial(P2, P3),
|
|
!.
|
|
|
|
list_to_term([N | NS], N * L) :-
|
|
number(N),
|
|
term_to_list(L, NS).
|
|
|