mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-21 12:23:44 +00:00
160 lines
3.1 KiB
Plaintext
160 lines
3.1 KiB
Plaintext
% generated: 7 March 1990
|
|
% option(s):
|
|
%
|
|
% (deriv) times10
|
|
%
|
|
% David H. D. Warren
|
|
%
|
|
% symbolic derivatives
|
|
|
|
:- module deriv2.
|
|
|
|
:- import_module int, io.
|
|
|
|
:- interface.
|
|
|
|
:- type expr ---> x
|
|
; num(int)
|
|
; expr + expr
|
|
; expr - expr
|
|
; expr * expr
|
|
; expr / expr
|
|
; - expr
|
|
; expr ** int
|
|
; log(expr)
|
|
; exp(expr)
|
|
.
|
|
|
|
:- pred main(io__state, io__state).
|
|
:- mode main(di, uo) is semidet.
|
|
|
|
main --> main6(_, _, _, _).
|
|
|
|
:- pred main6(expr, expr, expr, expr, io__state, io__state).
|
|
:- mode main6(out, out, out, out, di, uo) is semidet.
|
|
|
|
:- pred main4(expr, expr, expr, expr).
|
|
:- mode main4(out, out, out, out) is semidet.
|
|
|
|
:- implementation.
|
|
|
|
main6(E1, E2, E3, E4) -->
|
|
{ main4(E1, E2, E3, E4) },
|
|
print_expr(E1),
|
|
io__write_string("\n\n"),
|
|
print_expr(E2),
|
|
io__write_string("\n\n"),
|
|
print_expr(E3),
|
|
io__write_string("\n\n"),
|
|
print_expr(E4),
|
|
io__write_string("\n").
|
|
|
|
:- pred times10(expr).
|
|
:- mode times10(out) is semidet.
|
|
|
|
:- pred log10(expr).
|
|
:- mode log10(out) is semidet.
|
|
|
|
:- pred ops8(expr).
|
|
:- mode ops8(out) is semidet.
|
|
|
|
:- pred divide10(expr).
|
|
:- mode divide10(out) is semidet.
|
|
|
|
:- pred d(expr, expr, expr).
|
|
:- mode d(in, in, out) is semidet.
|
|
|
|
:- pred print_expr(expr, io__state, io__state).
|
|
:- mode print_expr(in, di, uo) is det.
|
|
|
|
print_expr(x) -->
|
|
io__write_string("x").
|
|
print_expr(num(N)) -->
|
|
io__write_string("num("),
|
|
io__write_int(N),
|
|
io__write_string(")").
|
|
print_expr(log(E)) -->
|
|
io__write_string("log("),
|
|
print_expr(E),
|
|
io__write_string(")").
|
|
print_expr(exp(E)) -->
|
|
io__write_string("exp("),
|
|
print_expr(E),
|
|
io__write_string(")").
|
|
print_expr(E ** N) -->
|
|
io__write_string("pow("),
|
|
print_expr(E),
|
|
io__write_string(", "),
|
|
io__write_int(N),
|
|
io__write_string(")").
|
|
print_expr(E1 + E2) -->
|
|
io__write_string("plus("),
|
|
print_expr(E1),
|
|
io__write_string(", "),
|
|
print_expr(E2),
|
|
io__write_string(")").
|
|
print_expr(E1 - E2) -->
|
|
io__write_string("minus("),
|
|
print_expr(E1),
|
|
io__write_string(", "),
|
|
print_expr(E2),
|
|
io__write_string(")").
|
|
print_expr(E1 * E2) -->
|
|
io__write_string("times("),
|
|
print_expr(E1),
|
|
io__write_string(", "),
|
|
print_expr(E2),
|
|
io__write_string(")").
|
|
print_expr(E1 / E2) -->
|
|
io__write_string("div("),
|
|
print_expr(E1),
|
|
io__write_string(", "),
|
|
print_expr(E2),
|
|
io__write_string(")").
|
|
print_expr(-E) -->
|
|
io__write_string("neg("),
|
|
print_expr(E),
|
|
io__write_string(")").
|
|
|
|
main4(E1, E2, E3, E4) :-
|
|
ops8(E1),
|
|
divide10(E2),
|
|
log10(E3),
|
|
times10(E4).
|
|
|
|
times10(E) :-
|
|
d(x * x * x * x * x * x * x * x * x * x * x, x, E).
|
|
|
|
log10(E) :-
|
|
d(log(log(log(log(log(log(log(log(log(log(x)))))))))), x, E).
|
|
|
|
ops8(E) :-
|
|
d((x + num(1)) * ((x ** 2 + num(2)) * (x ** 3 + num(3))), x, E).
|
|
|
|
divide10(E) :-
|
|
d(x / x / x / x / x / x / x / x / x / x / x, x, E).
|
|
|
|
d(U + V, X, DU + DV) :-
|
|
d(U, X, DU),
|
|
d(V, X, DV).
|
|
d(U - V, X, DU - DV) :-
|
|
d(U, X, DU),
|
|
d(V, X, DV).
|
|
d(U * V, X, DU * V + U * DV) :-
|
|
d(U, X, DU),
|
|
d(V, X, DV).
|
|
d(U / V, X, (DU * V - U * DV) / (V ** 2)) :-
|
|
d(U, X, DU),
|
|
d(V, X, DV).
|
|
d(U ** N, X, DU * num(N) * (U ** N1)) :-
|
|
N1 is N - 1,
|
|
d(U, X, DU).
|
|
d(-U, X, -DU) :-
|
|
d(U, X, DU).
|
|
d(exp(U), X, exp(U) * DU) :-
|
|
d(U, X, DU).
|
|
d(log(U), X, DU / U) :-
|
|
d(U, X, DU).
|
|
d(x, x, num(1)).
|
|
d(num(_), _, num(0)).
|