// exponential function
//////////
-ex exp_evalf(ex const & x)
+static ex exp_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return exp(ex_to_numeric(x)); // -> numeric exp(numeric)
}
-ex exp_eval(ex const & x)
+static ex exp_eval(ex const & x)
{
// exp(0) -> 1
if (x.is_zero()) {
return exp(x).hold();
}
-ex exp_diff(ex const & x, unsigned diff_param)
+static ex exp_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// natural logarithm
//////////
-ex log_evalf(ex const & x)
+static ex log_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return log(ex_to_numeric(x)); // -> numeric log(numeric)
}
-ex log_eval(ex const & x)
+static ex log_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// log(1) -> 0
return log(x).hold();
}
-ex log_diff(ex const & x, unsigned diff_param)
+static ex log_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// sine (trigonometric function)
//////////
-ex sin_evalf(ex const & x)
+static ex sin_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return sin(ex_to_numeric(x)); // -> numeric sin(numeric)
}
-ex sin_eval(ex const & x)
+static ex sin_eval(ex const & x)
{
// sin(n*Pi) -> 0
ex xOverPi=x/Pi;
return sin(x).hold();
}
-ex sin_diff(ex const & x, unsigned diff_param)
+static ex sin_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// cosine (trigonometric function)
//////////
-ex cos_evalf(ex const & x)
+static ex cos_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return cos(ex_to_numeric(x)); // -> numeric cos(numeric)
}
-ex cos_eval(ex const & x)
+static ex cos_eval(ex const & x)
{
// cos(n*Pi) -> {+|-}1
ex xOverPi=x/Pi;
return cos(x).hold();
}
-ex cos_diff(ex const & x, unsigned diff_param)
+static ex cos_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// tangent (trigonometric function)
//////////
-ex tan_evalf(ex const & x)
+static ex tan_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return tan(ex_to_numeric(x));
}
-ex tan_eval(ex const & x)
+static ex tan_eval(ex const & x)
{
// tan(n*Pi/3) -> {0|3^(1/2)|-(3^(1/2))}
ex ThreeExOverPi=numTHREE()*x/Pi;
return tan(x).hold();
}
-ex tan_diff(ex const & x, unsigned diff_param)
+static ex tan_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse sine (arc sine)
//////////
-ex asin_evalf(ex const & x)
+static ex asin_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return asin(ex_to_numeric(x)); // -> numeric asin(numeric)
}
-ex asin_eval(ex const & x)
+static ex asin_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// asin(0) -> 0
return asin(x).hold();
}
-ex asin_diff(ex const & x, unsigned diff_param)
+static ex asin_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse cosine (arc cosine)
//////////
-ex acos_evalf(ex const & x)
+static ex acos_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return acos(ex_to_numeric(x)); // -> numeric acos(numeric)
}
-ex acos_eval(ex const & x)
+static ex acos_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// acos(1) -> 0
return acos(x).hold();
}
-ex acos_diff(ex const & x, unsigned diff_param)
+static ex acos_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse tangent (arc tangent)
//////////
-ex atan_evalf(ex const & x)
+static ex atan_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return atan(ex_to_numeric(x)); // -> numeric atan(numeric)
}
-ex atan_eval(ex const & x)
+static ex atan_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// atan(0) -> 0
return atan(x).hold();
}
-ex atan_diff(ex const & x, unsigned diff_param)
+static ex atan_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse tangent (atan2(y,x))
//////////
-ex atan2_evalf(ex const & y, ex const & x)
+static ex atan2_evalf(ex const & y, ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(y,numeric)
return atan(ex_to_numeric(y),ex_to_numeric(x)); // -> numeric atan(numeric)
}
-ex atan2_eval(ex const & y, ex const & x)
+static ex atan2_eval(ex const & y, ex const & x)
{
if (y.info(info_flags::numeric) && !y.info(info_flags::rational) &&
x.info(info_flags::numeric) && !x.info(info_flags::rational)) {
return atan2(y,x).hold();
}
-ex atan2_diff(ex const & y, ex const & x, unsigned diff_param)
+static ex atan2_diff(ex const & y, ex const & x, unsigned diff_param)
{
ASSERT(diff_param<2);
// hyperbolic sine (trigonometric function)
//////////
-ex sinh_evalf(ex const & x)
+static ex sinh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return sinh(ex_to_numeric(x)); // -> numeric sinh(numeric)
}
-ex sinh_eval(ex const & x)
+static ex sinh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// sinh(0) -> 0
return sinh(x).hold();
}
-ex sinh_diff(ex const & x, unsigned diff_param)
+static ex sinh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// hyperbolic cosine (trigonometric function)
//////////
-ex cosh_evalf(ex const & x)
+static ex cosh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return cosh(ex_to_numeric(x)); // -> numeric cosh(numeric)
}
-ex cosh_eval(ex const & x)
+static ex cosh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// cosh(0) -> 1
return cosh(x).hold();
}
-ex cosh_diff(ex const & x, unsigned diff_param)
+static ex cosh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// hyperbolic tangent (trigonometric function)
//////////
-ex tanh_evalf(ex const & x)
+static ex tanh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return tanh(ex_to_numeric(x)); // -> numeric tanh(numeric)
}
-ex tanh_eval(ex const & x)
+static ex tanh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// tanh(0) -> 0
return tanh(x).hold();
}
-ex tanh_diff(ex const & x, unsigned diff_param)
+static ex tanh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse hyperbolic sine (trigonometric function)
//////////
-ex asinh_evalf(ex const & x)
+static ex asinh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return asinh(ex_to_numeric(x)); // -> numeric asinh(numeric)
}
-ex asinh_eval(ex const & x)
+static ex asinh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// asinh(0) -> 0
return asinh(x).hold();
}
-ex asinh_diff(ex const & x, unsigned diff_param)
+static ex asinh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse hyperbolic cosine (trigonometric function)
//////////
-ex acosh_evalf(ex const & x)
+static ex acosh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return acosh(ex_to_numeric(x)); // -> numeric acosh(numeric)
}
-ex acosh_eval(ex const & x)
+static ex acosh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// acosh(0) -> Pi*I/2
return acosh(x).hold();
}
-ex acosh_diff(ex const & x, unsigned diff_param)
+static ex acosh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);
// inverse hyperbolic tangent (trigonometric function)
//////////
-ex atanh_evalf(ex const & x)
+static ex atanh_evalf(ex const & x)
{
BEGIN_TYPECHECK
TYPECHECK(x,numeric)
return atanh(ex_to_numeric(x)); // -> numeric atanh(numeric)
}
-ex atanh_eval(ex const & x)
+static ex atanh_eval(ex const & x)
{
if (x.info(info_flags::numeric)) {
// atanh(0) -> 0
return atanh(x).hold();
}
-ex atanh_diff(ex const & x, unsigned diff_param)
+static ex atanh_diff(ex const & x, unsigned diff_param)
{
ASSERT(diff_param==0);