spad
)abbrev package EF ElementaryFunction
++ Author: Manuel Bronstein
++ Date Created: 1987
++ Date Last Updated: 10 April 1995
++ Keywords: elementary, function, logarithm, exponential.
++ Examples: )r EF INPUT
++ Description: Provides elementary functions over an integral domain.
ElementaryFunction(R, F) : Exports == Implementation where
R : Join(Comparable, IntegralDomain)
F : Join(FunctionSpace R, RadicalCategory)
B ==> Boolean
L ==> List
Z ==> Integer
OP ==> BasicOperator
K ==> Kernel F
INV ==> error "Invalid argument"
Exports ==> with
exp : F -> F
++ exp(x) applies the exponential operator to x
log : F -> F
++ log(x) applies the logarithm operator to x
sin : F -> F
++ sin(x) applies the sine operator to x
cos : F -> F
++ cos(x) applies the cosine operator to x
tan : F -> F
++ tan(x) applies the tangent operator to x
cot : F -> F
++ cot(x) applies the cotangent operator to x
sec : F -> F
++ sec(x) applies the secant operator to x
csc : F -> F
++ csc(x) applies the cosecant operator to x
asin : F -> F
++ asin(x) applies the inverse sine operator to x
acos : F -> F
++ acos(x) applies the inverse cosine operator to x
atan : F -> F
++ atan(x) applies the inverse tangent operator to x
acot : F -> F
++ acot(x) applies the inverse cotangent operator to x
asec : F -> F
++ asec(x) applies the inverse secant operator to x
acsc : F -> F
++ acsc(x) applies the inverse cosecant operator to x
sinh : F -> F
++ sinh(x) applies the hyperbolic sine operator to x
cosh : F -> F
++ cosh(x) applies the hyperbolic cosine operator to x
tanh : F -> F
++ tanh(x) applies the hyperbolic tangent operator to x
coth : F -> F
++ coth(x) applies the hyperbolic cotangent operator to x
sech : F -> F
++ sech(x) applies the hyperbolic secant operator to x
csch : F -> F
++ csch(x) applies the hyperbolic cosecant operator to x
asinh : F -> F
++ asinh(x) applies the inverse hyperbolic sine operator to x
acosh : F -> F
++ acosh(x) applies the inverse hyperbolic cosine operator to x
atanh : F -> F
++ atanh(x) applies the inverse hyperbolic tangent operator to x
acoth : F -> F
++ acoth(x) applies the inverse hyperbolic cotangent operator to x
asech : F -> F
++ asech(x) applies the inverse hyperbolic secant operator to x
acsch : F -> F
++ acsch(x) applies the inverse hyperbolic cosecant operator to x
pi : () -> F
++ pi() returns the pi operator
belong? : OP -> Boolean
++ belong?(p) returns true if operator p is elementary
operator : OP -> OP
++ operator(p) returns an elementary operator with the same symbol as p
-- the following should be local, but are conditional
iisqrt2 : () -> F
++ iisqrt2() should be local but conditional
iisqrt3 : () -> F
++ iisqrt3() should be local but conditional
iiexp : F -> F
++ iiexp(x) should be local but conditional
iilog : F -> F
++ iilog(x) should be local but conditional
iisin : F -> F
++ iisin(x) should be local but conditional
iicos : F -> F
++ iicos(x) should be local but conditional
iitan : F -> F
++ iitan(x) should be local but conditional
iicot : F -> F
++ iicot(x) should be local but conditional
iisec : F -> F
++ iisec(x) should be local but conditional
iicsc : F -> F
++ iicsc(x) should be local but conditional
iiasin : F -> F
++ iiasin(x) should be local but conditional
iiacos : F -> F
++ iiacos(x) should be local but conditional
iiatan : F -> F
++ iiatan(x) should be local but conditional
iiacot : F -> F
++ iiacot(x) should be local but conditional
iiasec : F -> F
++ iiasec(x) should be local but conditional
iiacsc : F -> F
++ iiacsc(x) should be local but conditional
iisinh : F -> F
++ iisinh(x) should be local but conditional
iicosh : F -> F
++ iicosh(x) should be local but conditional
iitanh : F -> F
++ iitanh(x) should be local but conditional
iicoth : F -> F
++ iicoth(x) should be local but conditional
iisech : F -> F
++ iisech(x) should be local but conditional
iicsch : F -> F
++ iicsch(x) should be local but conditional
iiasinh : F -> F
++ iiasinh(x) should be local but conditional
iiacosh : F -> F
++ iiacosh(x) should be local but conditional
iiatanh : F -> F
++ iiatanh(x) should be local but conditional
iiacoth : F -> F
++ iiacoth(x) should be local but conditional
iiasech : F -> F
++ iiasech(x) should be local but conditional
iiacsch : F -> F
++ iiacsch(x) should be local but conditional
specialTrigs:(F, L Record(func:F,pole:B)) -> Union(F, "failed")
++ specialTrigs(x, l) should be local but conditional
localReal? : F -> Boolean
++ localReal?(x) should be local but conditional
Implementation ==> add
ELEM := 'elem
ipi : List F -> F
iexp : F -> F
ilog : F -> F
iiilog : F -> F
isin : F -> F
icos : F -> F
itan : F -> F
icot : F -> F
isec : F -> F
icsc : F -> F
iasin : F -> F
iacos : F -> F
iatan : F -> F
iacot : F -> F
iasec : F -> F
iacsc : F -> F
isinh : F -> F
icosh : F -> F
itanh : F -> F
icoth : F -> F
isech : F -> F
icsch : F -> F
iasinh : F -> F
iacosh : F -> F
iatanh : F -> F
iacoth : F -> F
iasech : F -> F
iacsch : F -> F
dropfun : F -> F
kernel : F -> K
posrem : (Z, Z) -> Z
iisqrt1 : () -> F
valueOrPole : Record(func : F, pole : B) -> F
oppi := operator('pi)$CommonOperators
oplog := operator('log)$CommonOperators
opexp := operator('exp)$CommonOperators
opsin := operator('sin)$CommonOperators
opcos := operator('cos)$CommonOperators
optan := operator('tan)$CommonOperators
opcot := operator('cot)$CommonOperators
opsec := operator('sec)$CommonOperators
opcsc := operator('csc)$CommonOperators
opasin := operator('asin)$CommonOperators
opacos := operator('acos)$CommonOperators
opatan := operator('atan)$CommonOperators
opacot := operator('acot)$CommonOperators
opasec := operator('asec)$CommonOperators
opacsc := operator('acsc)$CommonOperators
opsinh := operator('sinh)$CommonOperators
opcosh := operator('cosh)$CommonOperators
optanh := operator('tanh)$CommonOperators
opcoth := operator('coth)$CommonOperators
opsech := operator('sech)$CommonOperators
opcsch := operator('csch)$CommonOperators
opasinh := operator('asinh)$CommonOperators
opacosh := operator('acosh)$CommonOperators
opatanh := operator('atanh)$CommonOperators
opacoth := operator('acoth)$CommonOperators
opasech := operator('asech)$CommonOperators
opacsch := operator('acsch)$CommonOperators
-- Pi is a domain...
Pie, isqrt1, isqrt2, isqrt3 : F
-- following code is conditionalized on arbitraryPrecision to recompute in
-- case user changes the precision
if R has TranscendentalFunctionCategory then
Pie := pi()$R :: F
else
Pie := kernel(oppi, nil()$List(F))
if R has TranscendentalFunctionCategory and R has arbitraryPrecision then
pi() == pi()$R :: F
else
pi() == Pie
if R has imaginary : () -> R then
isqrt1 := imaginary()$R :: F
else isqrt1 := sqrt(-1::F)
if R has RadicalCategory then
isqrt2 := sqrt(2::R)::F
isqrt3 := sqrt(3::R)::F
else
isqrt2 := sqrt(2::F)
isqrt3 := sqrt(3::F)
iisqrt1() == isqrt1
if R has RadicalCategory and R has arbitraryPrecision then
iisqrt2() == sqrt(2::R)::F
iisqrt3() == sqrt(3::R)::F
else
iisqrt2() == isqrt2
iisqrt3() == isqrt3
ipi l == pi()
log x == oplog x
exp x == opexp x
sin x == opsin x
cos x == opcos x
tan x == optan x
cot x == opcot x
sec x == opsec x
csc x == opcsc x
asin x == opasin x
acos x == opacos x
atan x == opatan x
acot x == opacot x
asec x == opasec x
acsc x == opacsc x
sinh x == opsinh x
cosh x == opcosh x
tanh x == optanh x
coth x == opcoth x
sech x == opsech x
csch x == opcsch x
asinh x == opasinh x
acosh x == opacosh x
atanh x == opatanh x
acoth x == opacoth x
asech x == opasech x
acsch x == opacsch x
kernel x == retract(x)@K
posrem(n, m) == ((r := n rem m) < 0 => r + m; r)
valueOrPole rec == (rec.pole => INV; rec.func)
belong? op == has?(op, ELEM)
operator op ==
is?(op, 'pi) => oppi
is?(op, 'log) => oplog
is?(op, 'exp) => opexp
is?(op, 'sin) => opsin
is?(op, 'cos) => opcos
is?(op, 'tan) => optan
is?(op, 'cot) => opcot
is?(op, 'sec) => opsec
is?(op, 'csc) => opcsc
is?(op, 'asin) => opasin
is?(op, 'acos) => opacos
is?(op, 'atan) => opatan
is?(op, 'acot) => opacot
is?(op, 'asec) => opasec
is?(op, 'acsc) => opacsc
is?(op, 'sinh) => opsinh
is?(op, 'cosh) => opcosh
is?(op, 'tanh) => optanh
is?(op, 'coth) => opcoth
is?(op, 'sech) => opsech
is?(op, 'csch) => opcsch
is?(op, 'asinh) => opasinh
is?(op, 'acosh) => opacosh
is?(op, 'atanh) => opatanh
is?(op, 'acoth) => opacoth
is?(op, 'asech) => opasech
is?(op, 'acsch) => opacsch
error "Not an elementary operator"
dropfun x ==
((k := retractIfCan(x)@Union(K, "failed")) case "failed") or
empty?(argument(k::K)) => 0
first argument(k::K)
if R has RetractableTo Z then
specialTrigs(x, values) ==
(r := retractIfCan(y := x/pi())@Union(Fraction Z, "failed"))
case "failed" => "failed"
q := r::Fraction(Integer)
m := minIndex values
(n := retractIfCan(q)@Union(Z, "failed")) case Z =>
even?(n::Z) => valueOrPole(values.m)
valueOrPole(values.(m+1))
(n := retractIfCan(2*q)@Union(Z, "failed")) case Z =>
-- one?(s := posrem(n::Z, 4)) => valueOrPole(values.(m+2))
(s := posrem(n::Z, 4)) = 1 => valueOrPole(values.(m+2))
valueOrPole(values.(m+3))
(n := retractIfCan(3*q)@Union(Z, "failed")) case Z =>
-- one?(s := posrem(n::Z, 6)) => valueOrPole(values.(m+4))
(s := posrem(n::Z, 6)) = 1 => valueOrPole(values.(m+4))
s = 2 => valueOrPole(values.(m+5))
s = 4 => valueOrPole(values.(m+6))
valueOrPole(values.(m+7))
(n := retractIfCan(4*q)@Union(Z, "failed")) case Z =>
-- one?(s := posrem(n::Z, 8)) => valueOrPole(values.(m+8))
(s := posrem(n::Z, 8)) = 1 => valueOrPole(values.(m+8))
s = 3 => valueOrPole(values.(m+9))
s = 5 => valueOrPole(values.(m+10))
valueOrPole(values.(m+11))
(n := retractIfCan(6*q)@Union(Z, "failed")) case Z =>
-- one?(s := posrem(n::Z, 12)) => valueOrPole(values.(m+12))
(s := posrem(n::Z, 12)) = 1 => valueOrPole(values.(m+12))
s = 5 => valueOrPole(values.(m+13))
s = 7 => valueOrPole(values.(m+14))
valueOrPole(values.(m+15))
"failed"
else specialTrigs(x, values) == "failed"
isin x ==
zero? x => 0
y := dropfun x
is?(x, opasin) => y
is?(x, opacos) => sqrt(1 - y^2)
is?(x, opatan) => y / sqrt(1 + y^2)
is?(x, opacot) => inv sqrt(1 + y^2)
is?(x, opasec) => sqrt(y^2 - 1) / y
is?(x, opacsc) => inv y
h := inv(2::F)
s2 := h * iisqrt2()
s3 := h * iisqrt3()
u := specialTrigs(x, [[0, false], [0, false], [1, false], [-1, false],
[s3, false], [s3, false], [-s3, false], [-s3, false],
[s2, false], [s2, false], [-s2, false], [-s2, false],
[h, false], [h, false], [-h, false], [-h, false]])
u case F => u :: F
kernel(opsin, x)
icos x ==
zero? x => 1
y := dropfun x
is?(x, opasin) => sqrt(1 - y^2)
is?(x, opacos) => y
is?(x, opatan) => inv sqrt(1 + y^2)
is?(x, opacot) => y / sqrt(1 + y^2)
is?(x, opasec) => inv y
is?(x, opacsc) => sqrt(y^2 - 1) / y
h := inv(2::F)
s2 := h * iisqrt2()
s3 := h * iisqrt3()
u := specialTrigs(x, [[1, false], [-1, false], [0, false], [0, false],
[h, false], [-h, false], [-h, false], [h, false],
[s2, false], [-s2, false], [-s2, false], [s2, false],
[s3, false], [-s3, false], [-s3, false], [s3, false]])
u case F => u :: F
kernel(opcos, x)
itan x ==
zero? x => 0
y := dropfun x
is?(x, opasin) => y / sqrt(1 - y^2)
is?(x, opacos) => sqrt(1 - y^2) / y
is?(x, opatan) => y
is?(x, opacot) => inv y
is?(x, opasec) => sqrt(y^2 - 1)
is?(x, opacsc) => inv sqrt(y^2 - 1)
s33 := (s3 := iisqrt3()) / (3::F)
u := specialTrigs(x, [[0, false], [0, false], [0, true], [0, true],
[s3, false], [-s3, false], [s3, false], [-s3, false],
[1, false], [-1, false], [1, false], [-1, false],
[s33, false], [-s33, false], [s33, false], [-s33, false]])
u case F => u :: F
kernel(optan, x)
icot x ==
zero? x => INV
y := dropfun x
is?(x, opasin) => sqrt(1 - y^2) / y
is?(x, opacos) => y / sqrt(1 - y^2)
is?(x, opatan) => inv y
is?(x, opacot) => y
is?(x, opasec) => inv sqrt(y^2 - 1)
is?(x, opacsc) => sqrt(y^2 - 1)
s33 := (s3 := iisqrt3()) / (3::F)
u := specialTrigs(x, [[0, true], [0, true], [0, false], [0, false],
[s33, false], [-s33, false], [s33, false], [-s33, false],
[1, false], [-1, false], [1, false], [-1, false],
[s3, false], [-s3, false], [s3, false], [-s3, false]])
u case F => u :: F
kernel(opcot, x)
isec x ==
zero? x => 1
y := dropfun x
is?(x, opasin) => inv sqrt(1 - y^2)
is?(x, opacos) => inv y
is?(x, opatan) => sqrt(1 + y^2)
is?(x, opacot) => sqrt(1 + y^2) / y
is?(x, opasec) => y
is?(x, opacsc) => y / sqrt(y^2 - 1)
s2 := iisqrt2()
s3 := 2 * iisqrt3() / (3::F)
h := 2::F
u := specialTrigs(x, [[1, false], [-1, false], [0, true], [0, true],
[h, false], [-h, false], [-h, false], [h, false],
[s2, false], [-s2, false], [-s2, false], [s2, false],
[s3, false], [-s3, false], [-s3, false], [s3, false]])
u case F => u :: F
kernel(opsec, x)
icsc x ==
zero? x => INV
y := dropfun x
is?(x, opasin) => inv y
is?(x, opacos) => inv sqrt(1 - y^2)
is?(x, opatan) => sqrt(1 + y^2) / y
is?(x, opacot) => sqrt(1 + y^2)
is?(x, opasec) => y / sqrt(y^2 - 1)
is?(x, opacsc) => y
s2 := iisqrt2()
s3 := 2 * iisqrt3() / (3::F)
h := 2::F
u := specialTrigs(x, [[0, true], [0, true], [1, false], [-1, false],
[s3, false], [s3, false], [-s3, false], [-s3, false],
[s2, false], [s2, false], [-s2, false], [-s2, false],
[h, false], [h, false], [-h, false], [-h, false]])
u case F => u :: F
kernel(opcsc, x)
iasin x ==
zero? x => 0
-- one? x => pi() / (2::F)
(x = 1) => pi() / (2::F)
x = -1 => - pi() / (2::F)
-- y := dropfun x
-- is?(x, opsin) => y
-- is?(x, opcos) => pi() / (2::F) - y
kernel(opasin, x)
iacos x ==
zero? x => pi() / (2::F)
-- one? x => 0
(x = 1) => 0
x = -1 => pi()
-- y := dropfun x
-- is?(x, opsin) => pi() / (2::F) - y
-- is?(x, opcos) => y
kernel(opacos, x)
iatan x ==
zero? x => 0
-- one? x => pi() / (4::F)
(x = 1) => pi() / (4::F)
x = -1 => - pi() / (4::F)
x = (r3 := iisqrt3()) => pi() / (3::F)
-- one?(x*r3) => pi() / (6::F)
(x*r3) = 1 => pi() / (6::F)
-- y := dropfun x
-- is?(x, optan) => y
-- is?(x, opcot) => pi() / (2::F) - y
kernel(opatan, x)
iacot x ==
zero? x => pi() / (2::F)
-- one? x => pi() / (4::F)
(x = 1) => pi() / (4::F)
x = -1 => 3 * pi() / (4::F)
x = (r3 := iisqrt3()) => pi() / (6::F)
x = -r3 => 5 * pi() / (6::F)
-- one?(xx := x*r3) => pi() / (3::F)
(xx := x*r3) = 1 => pi() / (3::F)
xx = -1 => 2* pi() / (3::F)
-- y := dropfun x
-- is?(x, optan) => pi() / (2::F) - y
-- is?(x, opcot) => y
kernel(opacot, x)
iasec x ==
zero? x => INV
-- one? x => 0
(x = 1) => 0
x = -1 => pi()
-- y := dropfun x
-- is?(x, opsec) => y
-- is?(x, opcsc) => pi() / (2::F) - y
kernel(opasec, x)
iacsc x ==
zero? x => INV
-- one? x => pi() / (2::F)
(x = 1) => pi() / (2::F)
x = -1 => - pi() / (2::F)
-- y := dropfun x
-- is?(x, opsec) => pi() / (2::F) - y
-- is?(x, opcsc) => y
kernel(opacsc, x)
isinh x ==
zero? x => 0
y := dropfun x
is?(x, opasinh) => y
is?(x, opacosh) => sqrt(y^2 - 1)
is?(x, opatanh) => y / sqrt(1 - y^2)
is?(x, opacoth) => - inv sqrt(y^2 - 1)
is?(x, opasech) => sqrt(1 - y^2) / y
is?(x, opacsch) => inv y
kernel(opsinh, x)
icosh x ==
zero? x => 1
y := dropfun x
is?(x, opasinh) => sqrt(y^2 + 1)
is?(x, opacosh) => y
is?(x, opatanh) => inv sqrt(1 - y^2)
is?(x, opacoth) => y / sqrt(y^2 - 1)
is?(x, opasech) => inv y
is?(x, opacsch) => sqrt(y^2 + 1) / y
kernel(opcosh, x)
itanh x ==
zero? x => 0
y := dropfun x
is?(x, opasinh) => y / sqrt(y^2 + 1)
is?(x, opacosh) => sqrt(y^2 - 1) / y
is?(x, opatanh) => y
is?(x, opacoth) => inv y
is?(x, opasech) => sqrt(1 - y^2)
is?(x, opacsch) => inv sqrt(y^2 + 1)
kernel(optanh, x)
icoth x ==
zero? x => INV
y := dropfun x
is?(x, opasinh) => sqrt(y^2 + 1) / y
is?(x, opacosh) => y / sqrt(y^2 - 1)
is?(x, opatanh) => inv y
is?(x, opacoth) => y
is?(x, opasech) => inv sqrt(1 - y^2)
is?(x, opacsch) => sqrt(y^2 + 1)
kernel(opcoth, x)
isech x ==
zero? x => 1
y := dropfun x
is?(x, opasinh) => inv sqrt(y^2 + 1)
is?(x, opacosh) => inv y
is?(x, opatanh) => sqrt(1 - y^2)
is?(x, opacoth) => sqrt(y^2 - 1) / y
is?(x, opasech) => y
is?(x, opacsch) => y / sqrt(y^2 + 1)
kernel(opsech, x)
icsch x ==
zero? x => INV
y := dropfun x
is?(x, opasinh) => inv y
is?(x, opacosh) => inv sqrt(y^2 - 1)
is?(x, opatanh) => sqrt(1 - y^2) / y
is?(x, opacoth) => - sqrt(y^2 - 1)
is?(x, opasech) => y / sqrt(1 - y^2)
is?(x, opacsch) => y
kernel(opcsch, x)
iasinh x ==
-- is?(x, opsinh) => first argument kernel x
kernel(opasinh, x)
iacosh x ==
-- is?(x, opcosh) => first argument kernel x
kernel(opacosh, x)
iatanh x ==
-- is?(x, optanh) => first argument kernel x
kernel(opatanh, x)
iacoth x ==
zero? x => INV
-- is?(x, opcoth) => first argument kernel x
kernel(opacoth, x)
iasech x ==
zero? x => INV
-- is?(x, opsech) => first argument kernel x
kernel(opasech, x)
iacsch x ==
zero? x => INV
-- is?(x, opcsch) => first argument kernel x
kernel(opacsch, x)
iexp x ==
zero? x => 1
is?(x, oplog) => first argument kernel x
smaller?(x, 0) and empty? variables x => inv iexp(-x)
R has RetractableTo Z =>
i := iisqrt1()
xi := x / i
y := xi / pi()
-- this test saves us a lot of effort in the common case
-- when no trigonometic simplifiaction is possible
retractIfCan(y)@Union(Fraction Z, "failed") case "failed" =>
kernel(opexp, x)
h := inv(2::F)
s2 := h * iisqrt2()
s3 := h * iisqrt3()
u := specialTrigs(xi, [[1, false], [-1, false], [i, false],
[-i, false], [h + i * s3, false], [-h + i * s3, false],
[-h - i * s3, false], [h - i * s3, false],
[s2 + i * s2, false], [-s2 + i * s2, false],
[-s2 - i * s2, false], [s2 - i * s2, false],
[s3 + i * h, false], [-s3 + i * h, false],
[-s3 - i * h, false], [s3 - i * h, false]])
u case F => u :: F
kernel(opexp, x)
kernel(opexp, x)
-- THIS DETERMINES WHEN TO PERFORM THE log exp f -> f SIMPLIFICATION
-- CURRENT BEHAVIOR:
-- IF R IS COMPLEX(S) THEN ONLY ELEMENTS WHICH ARE RETRACTABLE TO R
-- AND EQUAL TO THEIR CONJUGATES ARE DEEMED REAL (OVERRESTRICTIVE FOR NOW)
-- OTHERWISE (e.g. R = INT OR FRAC INT), ALL THE ELEMENTS ARE DEEMED REAL
if (R has imaginary : () -> R) and (R has conjugate : R -> R) then
localReal? x ==
(u := retractIfCan(x)@Union(R, "failed")) case R
and (u::R) = conjugate(u::R)
else localReal? x == true
iiilog x ==
zero? x => INV
-- one? x => 0
(x = 1) => 0
(u := isExpt(x, opexp)) case Record(var : K, exponent : Integer) =>
rec := u::Record(var : K, exponent : Integer)
arg := first argument(rec.var)
localReal? arg => rec.exponent * first argument(rec.var)
ilog x
ilog x
ilog x ==
-- ((num1 := one?(num := numer x)) or num = -1) and (den := denom x) ~= 1
((num1 := ((num := numer x) = 1)) or num = -1) and (den := denom x) ~= 1
and empty? variables x => - kernel(oplog, (num1 => den; -den)::F)
kernel(oplog, x)
if R has ElementaryFunctionCategory then
iilog x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iiilog x
log(r::R)::F
iiexp x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iexp x
exp(r::R)::F
else
iilog x == iiilog x
iiexp x == iexp x
if R has TrigonometricFunctionCategory then
iisin x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => isin x
sin(r::R)::F
iicos x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icos x
cos(r::R)::F
iitan x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => itan x
tan(r::R)::F
iicot x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icot x
cot(r::R)::F
iisec x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => isec x
sec(r::R)::F
iicsc x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icsc x
csc(r::R)::F
else
iisin x == isin x
iicos x == icos x
iitan x == itan x
iicot x == icot x
iisec x == isec x
iicsc x == icsc x
if R has ArcTrigonometricFunctionCategory then
iiasin x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iasin x
asin(r::R)::F
iiacos x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacos x
acos(r::R)::F
iiatan x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iatan x
atan(r::R)::F
iiacot x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacot x
acot(r::R)::F
iiasec x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iasec x
asec(r::R)::F
iiacsc x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacsc x
acsc(r::R)::F
else
iiasin x == iasin x
iiacos x == iacos x
iiatan x == iatan x
iiacot x == iacot x
iiasec x == iasec x
iiacsc x == iacsc x
if R has HyperbolicFunctionCategory then
iisinh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => isinh x
sinh(r::R)::F
iicosh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icosh x
cosh(r::R)::F
iitanh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => itanh x
tanh(r::R)::F
iicoth x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icoth x
coth(r::R)::F
iisech x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => isech x
sech(r::R)::F
iicsch x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => icsch x
csch(r::R)::F
else
iisinh x == isinh x
iicosh x == icosh x
iitanh x == itanh x
iicoth x == icoth x
iisech x == isech x
iicsch x == icsch x
if R has ArcHyperbolicFunctionCategory then
iiasinh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iasinh x
asinh(r::R)::F
iiacosh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacosh x
acosh(r::R)::F
iiatanh x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iatanh x
atanh(r::R)::F
iiacoth x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacoth x
acoth(r::R)::F
iiasech x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iasech x
asech(r::R)::F
iiacsch x ==
(r := retractIfCan(x)@Union(R,"failed")) case "failed" => iacsch x
acsch(r::R)::F
else
iiasinh x == iasinh x
iiacosh x == iacosh x
iiatanh x == iatanh x
iiacoth x == iacoth x
iiasech x == iasech x
iiacsch x == iacsch x
import from BasicOperatorFunctions1(F)
evaluate(oppi, ipi)
evaluate(oplog, iilog)
evaluate(opexp, iiexp)
evaluate(opsin, iisin)
evaluate(opcos, iicos)
evaluate(optan, iitan)
evaluate(opcot, iicot)
evaluate(opsec, iisec)
evaluate(opcsc, iicsc)
evaluate(opasin, iiasin)
evaluate(opacos, iiacos)
evaluate(opatan, iiatan)
evaluate(opacot, iiacot)
evaluate(opasec, iiasec)
evaluate(opacsc, iiacsc)
evaluate(opsinh, iisinh)
evaluate(opcosh, iicosh)
evaluate(optanh, iitanh)
evaluate(opcoth, iicoth)
evaluate(opsech, iisech)
evaluate(opcsch, iicsch)
evaluate(opasinh, iiasinh)
evaluate(opacosh, iiacosh)
evaluate(opatanh, iiatanh)
evaluate(opacoth, iiacoth)
evaluate(opasech, iiasech)
evaluate(opacsch, iiacsch)
derivative(opexp, exp)
derivative(oplog, inv)
derivative(opsin, cos)
derivative(opcos, (x : F) : F +-> - sin x)
derivative(optan, (x : F) : F +-> 1 + tan(x)^2)
derivative(opcot, (x : F) : F +-> - 1 - cot(x)^2)
derivative(opsec, (x : F) : F +-> tan(x) * sec(x))
derivative(opcsc, (x : F) : F +-> - cot(x) * csc(x))
derivative(opasin, (x : F) : F +-> inv sqrt(1 - x^2))
derivative(opacos, (x : F) : F +-> - inv sqrt(1 - x^2))
derivative(opatan, (x : F) : F +-> inv(1 + x^2))
derivative(opacot, (x : F) : F +-> - inv(1 + x^2))
derivative(opasec, (x : F) : F +-> inv(x^2 * sqrt(1 - inv(x^2))))
derivative(opacsc, (x : F) : F +-> - inv(x^2 * sqrt(1 - inv(x^2))))
derivative(opsinh, cosh)
derivative(opcosh, sinh)
derivative(optanh, (x : F) : F +-> 1 - tanh(x)^2)
derivative(opcoth, (x : F) : F +-> 1 - coth(x)^2)
derivative(opsech, (x : F) : F +-> - tanh(x) * sech(x))
derivative(opcsch, (x : F) : F +-> - coth(x) * csch(x))
derivative(opasinh, (x : F) : F +-> inv sqrt(1 + x^2))
derivative(opacosh, (x : F) : F +-> inv sqrt(x^2 - 1))
derivative(opatanh, (x : F) : F +-> inv(1 - x^2))
derivative(opacoth, (x : F) : F +-> inv(1 - x^2))
derivative(opasech, (x : F) : F +-> - inv(x^2 * sqrt(inv(x^2) - 1)))
derivative(opacsch, (x : F) : F +-> - inv(x^2 * sqrt(inv(x^2) + 1)))
--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
--All rights reserved.
--
--Redistribution and use in source and binary forms, with or without
--modification, are permitted provided that the following conditions are
--met:
--
-- - Redistributions of source code must retain the above copyright
-- notice, this list of conditions and the following disclaimer.
--
-- - 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.
--
-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the
-- names of its contributors may be used to endorse or promote products
-- derived from this software without specific prior written permission.
--
--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.
-- SPAD files for the functional world should be compiled in the
-- following order:
--
-- op kl fspace algfunc ELEMNTRY expr
spad
Compiling FriCAS source code from file
/var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/6831497810020874664-25px001.spad
using old system compiler.
EF abbreviates package ElementaryFunction
------------------------------------------------------------------------
initializing NRLIB EF for ElementaryFunction
compiling into NRLIB EF
****** Domain: R already in scope
****** Domain: F already in scope
****** Domain: R already in scope
augmenting R: (TranscendentalFunctionCategory)
****** Domain: R already in scope
augmenting R: (TranscendentalFunctionCategory)
****** Domain: R already in scope
augmenting R: (arbitraryPrecision)
compiling exported pi : () -> F
Time: 0.05 SEC.
compiling exported pi : () -> F
Time: 0 SEC.
compiling exported pi : () -> F
Time: 0 SEC.
augmenting R: (SIGNATURE R imaginary (R))
****** Domain: R already in scope
augmenting R: (RadicalCategory)
compiling local iisqrt1 : () -> F
Time: 0.01 SEC.
****** Domain: R already in scope
augmenting R: (RadicalCategory)
****** Domain: R already in scope
augmenting R: (arbitraryPrecision)
compiling exported iisqrt2 : () -> F
Time: 0 SEC.
compiling exported iisqrt3 : () -> F
Time: 0 SEC.
compiling exported iisqrt2 : () -> F
Time: 0 SEC.
compiling exported iisqrt3 : () -> F
Time: 0 SEC.
compiling exported iisqrt2 : () -> F
Time: 0 SEC.
compiling exported iisqrt3 : () -> F
Time: 0 SEC.
compiling local ipi : List F -> F
Time: 0 SEC.
compiling exported log : F -> F
Time: 0 SEC.
compiling exported exp : F -> F
Time: 0 SEC.
compiling exported sin : F -> F
Time: 0 SEC.
compiling exported cos : F -> F
Time: 0 SEC.
compiling exported tan : F -> F
Time: 0 SEC.
compiling exported cot : F -> F
Time: 0 SEC.
compiling exported sec : F -> F
Time: 0 SEC.
compiling exported csc : F -> F
Time: 0 SEC.
compiling exported asin : F -> F
Time: 0 SEC.
compiling exported acos : F -> F
Time: 0 SEC.
compiling exported atan : F -> F
Time: 0 SEC.
compiling exported acot : F -> F
Time: 0 SEC.
compiling exported asec : F -> F
Time: 0 SEC.
compiling exported acsc : F -> F
Time: 0 SEC.
compiling exported sinh : F -> F
Time: 0 SEC.
compiling exported cosh : F -> F
Time: 0 SEC.
compiling exported tanh : F -> F
Time: 0 SEC.
compiling exported coth : F -> F
Time: 0 SEC.
compiling exported sech : F -> F
Time: 0 SEC.
compiling exported csch : F -> F
Time: 0 SEC.
compiling exported asinh : F -> F
Time: 0 SEC.
compiling exported acosh : F -> F
Time: 0 SEC.
compiling exported atanh : F -> F
Time: 0 SEC.
compiling exported acoth : F -> F
Time: 0 SEC.
compiling exported asech : F -> F
Time: 0 SEC.
compiling exported acsch : F -> F
Time: 0.01 SEC.
compiling local kernel : F -> Kernel F
Time: 0 SEC.
compiling local posrem : (Integer,Integer) -> Integer
Time: 0 SEC.
compiling local valueOrPole : Record(func: F,pole: Boolean) -> F
Time: 0 SEC.
compiling exported belong? : BasicOperator -> Boolean
Time: 0 SEC.
compiling exported operator : BasicOperator -> BasicOperator
Time: 0.01 SEC.
compiling local dropfun : F -> F
Time: 0 SEC.
****** Domain: R already in scope
augmenting R: (RetractableTo (Integer))
compiling exported specialTrigs : (F,List Record(func: F,pole: Boolean)) -> Union(F,failed)
Time: 0.05 SEC.
compiling exported specialTrigs : (F,List Record(func: F,pole: Boolean)) -> Union(F,failed)
EF;specialTrigs;FLU;45 is replaced by CONS1failed
Time: 0 SEC.
compiling local isin : F -> F
Time: 0.03 SEC.
compiling local icos : F -> F
Time: 0.02 SEC.
compiling local itan : F -> F
Time: 0.02 SEC.
compiling local icot : F -> F
Time: 0.02 SEC.
compiling local isec : F -> F
Time: 0.03 SEC.
compiling local icsc : F -> F
Time: 0.02 SEC.
compiling local iasin : F -> F
Time: 0.01 SEC.
compiling local iacos : F -> F
Time: 0 SEC.
compiling local iatan : F -> F
Time: 0.01 SEC.
compiling local iacot : F -> F
Time: 0.03 SEC.
compiling local iasec : F -> F
Time: 0 SEC.
compiling local iacsc : F -> F
Time: 0 SEC.
compiling local isinh : F -> F
Time: 0.02 SEC.
compiling local icosh : F -> F
Time: 0.01 SEC.
compiling local itanh : F -> F
Time: 0.01 SEC.
compiling local icoth : F -> F
Time: 0.01 SEC.
compiling local isech : F -> F
Time: 0.01 SEC.
compiling local icsch : F -> F
Time: 0.02 SEC.
compiling local iasinh : F -> F
Time: 0 SEC.
compiling local iacosh : F -> F
Time: 0 SEC.
compiling local iatanh : F -> F
Time: 0 SEC.
compiling local iacoth : F -> F
Time: 0 SEC.
compiling local iasech : F -> F
Time: 0 SEC.
compiling local iacsch : F -> F
Time: 0 SEC.
compiling local iexp : F -> F
****** Domain: R already in scope
augmenting R: (RetractableTo (Integer))
Time: 0.03 SEC.
augmenting R: (SIGNATURE R imaginary (R))
augmenting R: (SIGNATURE R conjugate (R R))
compiling exported localReal? : F -> Boolean
Time: 0 SEC.
compiling exported localReal? : F -> Boolean
EF;localReal?;FB;72 is replaced by QUOTET
Time: 0 SEC.
compiling exported localReal? : F -> Boolean
EF;localReal?;FB;73 is replaced by QUOTET
Time: 0 SEC.
compiling local iiilog : F -> F
Time: 0.01 SEC.
compiling local ilog : F -> F
Time: 0.02 SEC.
****** Domain: R already in scope
augmenting R: (ElementaryFunctionCategory)
compiling exported iilog : F -> F
Time: 0 SEC.
compiling exported iiexp : F -> F
Time: 0 SEC.
compiling exported iilog : F -> F
Time: 0 SEC.
compiling exported iiexp : F -> F
Time: 0 SEC.
****** Domain: R already in scope
augmenting R: (TrigonometricFunctionCategory)
compiling exported iisin : F -> F
Time: 0 SEC.
compiling exported iicos : F -> F
Time: 0 SEC.
compiling exported iitan : F -> F
Time: 0 SEC.
compiling exported iicot : F -> F
Time: 0 SEC.
compiling exported iisec : F -> F
Time: 0.01 SEC.
compiling exported iicsc : F -> F
Time: 0 SEC.
compiling exported iisin : F -> F
Time: 0 SEC.
compiling exported iicos : F -> F
Time: 0 SEC.
compiling exported iitan : F -> F
Time: 0 SEC.
compiling exported iicot : F -> F
Time: 0 SEC.
compiling exported iisec : F -> F
Time: 0 SEC.
compiling exported iicsc : F -> F
Time: 0 SEC.
****** Domain: R already in scope
augmenting R: (ArcTrigonometricFunctionCategory)
compiling exported iiasin : F -> F
Time: 0 SEC.
compiling exported iiacos : F -> F
Time: 0 SEC.
compiling exported iiatan : F -> F
Time: 0.01 SEC.
compiling exported iiacot : F -> F
Time: 0 SEC.
compiling exported iiasec : F -> F
Time: 0 SEC.
compiling exported iiacsc : F -> F
Time: 0 SEC.
compiling exported iiasin : F -> F
Time: 0 SEC.
compiling exported iiacos : F -> F
Time: 0 SEC.
compiling exported iiatan : F -> F
Time: 0 SEC.
compiling exported iiacot : F -> F
Time: 0 SEC.
compiling exported iiasec : F -> F
Time: 0 SEC.
compiling exported iiacsc : F -> F
Time: 0 SEC.
****** Domain: R already in scope
augmenting R: (HyperbolicFunctionCategory)
compiling exported iisinh : F -> F
Time: 0 SEC.
compiling exported iicosh : F -> F
Time: 0 SEC.
compiling exported iitanh : F -> F
Time: 0 SEC.
compiling exported iicoth : F -> F
Time: 0.01 SEC.
compiling exported iisech : F -> F
Time: 0 SEC.
compiling exported iicsch : F -> F
Time: 0 SEC.
compiling exported iisinh : F -> F
Time: 0 SEC.
compiling exported iicosh : F -> F
Time: 0 SEC.
compiling exported iitanh : F -> F
Time: 0 SEC.
compiling exported iicoth : F -> F
Time: 0 SEC.
compiling exported iisech : F -> F
Time: 0 SEC.
compiling exported iicsch : F -> F
Time: 0 SEC.
****** Domain: R already in scope
augmenting R: (ArcHyperbolicFunctionCategory)
compiling exported iiasinh : F -> F
Time: 0 SEC.
compiling exported iiacosh : F -> F
Time: 0.01 SEC.
compiling exported iiatanh : F -> F
Time: 0 SEC.
compiling exported iiacoth : F -> F
Time: 0 SEC.
compiling exported iiasech : F -> F
Time: 0 SEC.
compiling exported iiacsch : F -> F
Time: 0 SEC.
compiling exported iiasinh : F -> F
Time: 0 SEC.
compiling exported iiacosh : F -> F
Time: 0 SEC.
compiling exported iiatanh : F -> F
Time: 0 SEC.
compiling exported iiacoth : F -> F
Time: 0 SEC.
compiling exported iiasech : F -> F
Time: 0 SEC.
compiling exported iiacsch : F -> F
Time: 0 SEC.
importing BasicOperatorFunctions1 F
(time taken in buildFunctor: 0)
;;; *** |ElementaryFunction| REDEFINED
;;; *** |ElementaryFunction| REDEFINED
Time: 0.37 SEC.
Warnings:
[1] pi: Pie has no value
[2] iisqrt1: isqrt1 has no value
[3] iisqrt2: isqrt2 has no value
[4] iisqrt3: isqrt3 has no value
[5] valueOrPole: pole has no value
[6] valueOrPole: func has no value
[7] iiilog: var has no value
[8] iiilog: exponent has no value
Cumulative Statistics for Constructor ElementaryFunction
Time: 0.87 seconds
finalizing NRLIB EF
Processing ElementaryFunction for Browser database:
--------constructor---------
--------(exp (F F))---------
--------(log (F F))---------
--------(sin (F F))---------
--------(cos (F F))---------
--------(tan (F F))---------
--------(cot (F F))---------
--------(sec (F F))---------
--------(csc (F F))---------
--------(asin (F F))---------
--------(acos (F F))---------
--------(atan (F F))---------
--------(acot (F F))---------
--------(asec (F F))---------
--------(acsc (F F))---------
--------(sinh (F F))---------
--------(cosh (F F))---------
--------(tanh (F F))---------
--------(coth (F F))---------
--------(sech (F F))---------
--------(csch (F F))---------
--------(asinh (F F))---------
--------(acosh (F F))---------
--------(atanh (F F))---------
--------(acoth (F F))---------
--------(asech (F F))---------
--------(acsch (F F))---------
--------(pi (F))---------
--------(belong? ((Boolean) (BasicOperator)))---------
--------(operator ((BasicOperator) (BasicOperator)))---------
--------(iisqrt2 (F))---------
--------(iisqrt3 (F))---------
--------(iiexp (F F))---------
--------(iilog (F F))---------
--------(iisin (F F))---------
--------(iicos (F F))---------
--------(iitan (F F))---------
--------(iicot (F F))---------
--------(iisec (F F))---------
--------(iicsc (F F))---------
--------(iiasin (F F))---------
--------(iiacos (F F))---------
--------(iiatan (F F))---------
--------(iiacot (F F))---------
--------(iiasec (F F))---------
--------(iiacsc (F F))---------
--------(iisinh (F F))---------
--------(iicosh (F F))---------
--------(iitanh (F F))---------
--------(iicoth (F F))---------
--------(iisech (F F))---------
--------(iicsch (F F))---------
--------(iiasinh (F F))---------
--------(iiacosh (F F))---------
--------(iiatanh (F F))---------
--------(iiacoth (F F))---------
--------(iiasech (F F))---------
--------(iiacsch (F F))---------
--------(specialTrigs ((Union F failed) F (List (Record (: func F) (: pole (Boolean))))))---------
--------(localReal? ((Boolean) F))---------
; compiling file "/var/aw/var/LatexWiki/EF.NRLIB/EF.lsp" (written 27 FEB 2015 01:03:16 PM):
; /var/aw/var/LatexWiki/EF.NRLIB/EF.fasl written
; compilation finished in 0:00:01.370
------------------------------------------------------------------------
ElementaryFunction is now explicitly exposed in frame initial
ElementaryFunction will be automatically loaded when needed from
/var/aw/var/LatexWiki/EF.NRLIB/EF