/** @file inifcns_trans.cpp * * Implementation of transcendental (and trigonometric and hyperbolic) * functions. */ /* * GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include "inifcns.h" #include "ex.h" #include "constant.h" #include "numeric.h" #include "power.h" #include "relational.h" #include "symbol.h" #include "utils.h" #ifndef NO_GINAC_NAMESPACE namespace GiNaC { #endif // ndef NO_GINAC_NAMESPACE ////////// // exponential function ////////// static ex exp_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(exp(x)) return exp(ex_to_numeric(x)); // -> numeric exp(numeric) } static ex exp_eval(ex const & x) { // exp(0) -> 1 if (x.is_zero()) { return _ex1(); } // exp(n*Pi*I/2) -> {+1|+I|-1|-I} ex TwoExOverPiI=(_ex2()*x)/(Pi*I); if (TwoExOverPiI.info(info_flags::integer)) { numeric z=mod(ex_to_numeric(TwoExOverPiI),_num4()); if (z.is_equal(_num0())) return _ex1(); if (z.is_equal(_num1())) return ex(I); if (z.is_equal(_num2())) return _ex_1(); if (z.is_equal(_num3())) return ex(-I); } // exp(log(x)) -> x if (is_ex_the_function(x, log)) return x.op(0); // exp(float) if (x.info(info_flags::numeric) && !x.info(info_flags::crational)) return exp_evalf(x); return exp(x).hold(); } static ex exp_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx exp(x) -> exp(x) return exp(x); } REGISTER_FUNCTION(exp, exp_eval, exp_evalf, exp_diff, NULL); ////////// // natural logarithm ////////// static ex log_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(log(x)) return log(ex_to_numeric(x)); // -> numeric log(numeric) } static ex log_eval(ex const & x) { if (x.info(info_flags::numeric)) { if (x.is_equal(_ex1())) // log(1) -> 0 return _ex0(); if (x.is_equal(_ex_1())) // log(-1) -> I*Pi return (I*Pi); if (x.is_equal(I)) // log(I) -> Pi*I/2 return (Pi*I*_num1_2()); if (x.is_equal(-I)) // log(-I) -> -Pi*I/2 return (Pi*I*_num_1_2()); if (x.is_equal(_ex0())) // log(0) -> infinity throw(std::domain_error("log_eval(): log(0)")); // log(float) if (!x.info(info_flags::crational)) return log_evalf(x); } // log(exp(t)) -> t (for real-valued t): if (is_ex_the_function(x, exp)) { ex t=x.op(0); if (t.info(info_flags::real)) return t; } return log(x).hold(); } static ex log_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx log(x) -> 1/x return power(x, -1); } REGISTER_FUNCTION(log, log_eval, log_evalf, log_diff, NULL); ////////// // sine (trigonometric function) ////////// static ex sin_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(sin(x)) return sin(ex_to_numeric(x)); // -> numeric sin(numeric) } static ex sin_eval(ex const & x) { // sin(n*Pi/6) -> { 0 | +/-1/2 | +/-sqrt(3)/2 | +/-1 } ex SixExOverPi = _ex6()*x/Pi; if (SixExOverPi.info(info_flags::integer)) { numeric z = smod(ex_to_numeric(SixExOverPi),_num12()); if (z.is_equal(_num_5())) // sin(7*Pi/6) -> -1/2 return _ex_1_2(); if (z.is_equal(_num_4())) // sin(8*Pi/6) -> -sqrt(3)/2 return _ex_1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num_3())) // sin(9*Pi/6) -> -1 return _ex_1(); if (z.is_equal(_num_2())) // sin(10*Pi/6) -> -sqrt(3)/2 return _ex_1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num_1())) // sin(11*Pi/6) -> -1/2 return _ex_1_2(); if (z.is_equal(_num0())) // sin(0) -> 0 return _ex0(); if (z.is_equal(_num1())) // sin(1*Pi/6) -> 1/2 return _ex1_2(); if (z.is_equal(_num2())) // sin(2*Pi/6) -> sqrt(3)/2 return _ex1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num3())) // sin(3*Pi/6) -> 1 return _ex1(); if (z.is_equal(_num4())) // sin(4*Pi/6) -> sqrt(3)/2 return _ex1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num5())) // sin(5*Pi/6) -> 1/2 return _ex1_2(); if (z.is_equal(_num6())) // sin(6*Pi/6) -> 0 return _ex0(); } if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // sin(asin(x)) -> x if (is_ex_the_function(x, asin)) return t; // sin(acos(x)) -> sqrt(1-x^2) if (is_ex_the_function(x, acos)) return power(_ex1()-power(t,_ex2()),_ex1_2()); // sin(atan(x)) -> x*(1+x^2)^(-1/2) if (is_ex_the_function(x, atan)) return t*power(_ex1()+power(t,_ex2()),_ex_1_2()); } // sin(float) -> float if (x.info(info_flags::numeric) && !x.info(info_flags::crational)) return sin_evalf(x); return sin(x).hold(); } static ex sin_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx sin(x) -> cos(x) return cos(x); } REGISTER_FUNCTION(sin, sin_eval, sin_evalf, sin_diff, NULL); ////////// // cosine (trigonometric function) ////////// static ex cos_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(cos(x)) return cos(ex_to_numeric(x)); // -> numeric cos(numeric) } static ex cos_eval(ex const & x) { // cos(n*Pi/6) -> { 0 | +/-1/2 | +/-sqrt(3)/2 | +/-1 } ex SixExOverPi = _ex6()*x/Pi; if (SixExOverPi.info(info_flags::integer)) { numeric z = smod(ex_to_numeric(SixExOverPi),_num12()); if (z.is_equal(_num_5())) // cos(7*Pi/6) -> -sqrt(3)/2 return _ex_1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num_4())) // cos(8*Pi/6) -> -1/2 return _ex_1_2(); if (z.is_equal(_num_3())) // cos(9*Pi/6) -> 0 return _ex0(); if (z.is_equal(_num_2())) // cos(10*Pi/6) -> 1/2 return _ex1_2(); if (z.is_equal(_num_1())) // cos(11*Pi/6) -> sqrt(3)/2 return _ex1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num0())) // cos(0) -> 1 return _ex1(); if (z.is_equal(_num1())) // cos(1*Pi/6) -> sqrt(3)/2 return _ex1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num2())) // cos(2*Pi/6) -> 1/2 return _ex1_2(); if (z.is_equal(_num3())) // cos(3*Pi/6) -> 0 return _ex0(); if (z.is_equal(_num4())) // cos(4*Pi/6) -> -1/2 return _ex_1_2(); if (z.is_equal(_num5())) // cos(5*Pi/6) -> -sqrt(3)/2 return _ex_1_2()*power(_ex3(),_ex1_2()); if (z.is_equal(_num6())) // cos(6*Pi/6) -> -1 return _ex_1(); } if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // cos(acos(x)) -> x if (is_ex_the_function(x, acos)) return t; // cos(asin(x)) -> (1-x^2)^(1/2) if (is_ex_the_function(x, asin)) return power(_ex1()-power(t,_ex2()),_ex1_2()); // cos(atan(x)) -> (1+x^2)^(-1/2) if (is_ex_the_function(x, atan)) return power(_ex1()+power(t,_ex2()),_ex_1_2()); } // cos(float) -> float if (x.info(info_flags::numeric) && !x.info(info_flags::crational)) return cos_evalf(x); return cos(x).hold(); } static ex cos_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx cos(x) -> -sin(x) return _ex_1()*sin(x); } REGISTER_FUNCTION(cos, cos_eval, cos_evalf, cos_diff, NULL); ////////// // tangent (trigonometric function) ////////// static ex tan_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(tan(x)) // -> numeric tan(numeric) return tan(ex_to_numeric(x)); } static ex tan_eval(ex const & x) { // tan(n*Pi/6) -> { 0 | +/-sqrt(3) | +/-sqrt(3)/2 } ex SixExOverPi = _ex6()*x/Pi; if (SixExOverPi.info(info_flags::integer)) { numeric z = smod(ex_to_numeric(SixExOverPi),_num6()); if (z.is_equal(_num_2())) // tan(4*Pi/6) -> -sqrt(3) return _ex_1()*power(_ex3(),_ex1_2()); if (z.is_equal(_num_1())) // tan(5*Pi/6) -> -sqrt(3)/3 return _ex_1_3()*power(_ex3(),_ex1_2()); if (z.is_equal(_num0())) // tan(0) -> 0 return _ex0(); if (z.is_equal(_num1())) // tan(1*Pi/6) -> sqrt(3)/3 return _ex1_3()*power(_ex3(),_ex1_2()); if (z.is_equal(_num2())) // tan(2*Pi/6) -> sqrt(3) return power(_ex3(),_ex1_2()); if (z.is_equal(_num3())) // tan(3*Pi/6) -> infinity throw (std::domain_error("tan_eval(): infinity")); } if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // tan(atan(x)) -> x if (is_ex_the_function(x, atan)) return t; // tan(asin(x)) -> x*(1+x^2)^(-1/2) if (is_ex_the_function(x, asin)) return t*power(_ex1()-power(t,_ex2()),_ex_1_2()); // tan(acos(x)) -> (1-x^2)^(1/2)/x if (is_ex_the_function(x, acos)) return power(t,_ex_1())*power(_ex1()-power(t,_ex2()),_ex1_2()); } // tan(float) -> float if (x.info(info_flags::numeric) && !x.info(info_flags::crational)) { return tan_evalf(x); } return tan(x).hold(); } static ex tan_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx tan(x) -> 1+tan(x)^2; return (1+power(tan(x),_ex2())); } static ex tan_series(ex const & x, symbol const & s, ex const & point, int order) { // method: // Taylor series where there is no pole falls back to tan_diff. // On a pole simply expand sin(x)/cos(x). ex xpoint = x.subs(s==point); if (!(2*xpoint/Pi).info(info_flags::odd)) throw do_taylor(); // caught by function::series() // if we got here we have to care for a simple pole return (sin(x)/cos(x)).series(s, point, order+2); } REGISTER_FUNCTION(tan, tan_eval, tan_evalf, tan_diff, tan_series); ////////// // inverse sine (arc sine) ////////// static ex asin_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(asin(x)) return asin(ex_to_numeric(x)); // -> numeric asin(numeric) } static ex asin_eval(ex const & x) { if (x.info(info_flags::numeric)) { // asin(0) -> 0 if (x.is_zero()) return x; // asin(1/2) -> Pi/6 if (x.is_equal(_ex1_2())) return numeric(1,6)*Pi; // asin(1) -> Pi/2 if (x.is_equal(_ex1())) return _num1_2()*Pi; // asin(-1/2) -> -Pi/6 if (x.is_equal(_ex_1_2())) return numeric(-1,6)*Pi; // asin(-1) -> -Pi/2 if (x.is_equal(_ex_1())) return _num_1_2()*Pi; // asin(float) -> float if (!x.info(info_flags::crational)) return asin_evalf(x); } return asin(x).hold(); } static ex asin_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx asin(x) -> 1/sqrt(1-x^2) return power(1-power(x,_ex2()),_ex_1_2()); } REGISTER_FUNCTION(asin, asin_eval, asin_evalf, asin_diff, NULL); ////////// // inverse cosine (arc cosine) ////////// static ex acos_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(acos(x)) return acos(ex_to_numeric(x)); // -> numeric acos(numeric) } static ex acos_eval(ex const & x) { if (x.info(info_flags::numeric)) { // acos(1) -> 0 if (x.is_equal(_ex1())) return _ex0(); // acos(1/2) -> Pi/3 if (x.is_equal(_ex1_2())) return numeric(1,3)*Pi; // acos(0) -> Pi/2 if (x.is_zero()) return numeric(1,2)*Pi; // acos(-1/2) -> 2/3*Pi if (x.is_equal(_ex_1_2())) return numeric(2,3)*Pi; // acos(-1) -> Pi if (x.is_equal(_ex_1())) return Pi; // acos(float) -> float if (!x.info(info_flags::crational)) return acos_evalf(x); } return acos(x).hold(); } static ex acos_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx acos(x) -> -1/sqrt(1-x^2) return _ex_1()*power(1-power(x,_ex2()),_ex_1_2()); } REGISTER_FUNCTION(acos, acos_eval, acos_evalf, acos_diff, NULL); ////////// // inverse tangent (arc tangent) ////////// static ex atan_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(atan(x)) return atan(ex_to_numeric(x)); // -> numeric atan(numeric) } static ex atan_eval(ex const & x) { if (x.info(info_flags::numeric)) { // atan(0) -> 0 if (x.is_equal(_ex0())) return _ex0(); // atan(float) -> float if (!x.info(info_flags::crational)) return atan_evalf(x); } return atan(x).hold(); } static ex atan_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); return power(1+x*x, -1); } REGISTER_FUNCTION(atan, atan_eval, atan_evalf, atan_diff, NULL); ////////// // inverse tangent (atan2(y,x)) ////////// static ex atan2_evalf(ex const & y, ex const & x) { BEGIN_TYPECHECK TYPECHECK(y,numeric) TYPECHECK(x,numeric) END_TYPECHECK(atan2(y,x)) return atan(ex_to_numeric(y),ex_to_numeric(x)); // -> numeric atan(numeric) } static ex atan2_eval(ex const & y, ex const & x) { if (y.info(info_flags::numeric) && !y.info(info_flags::crational) && x.info(info_flags::numeric) && !x.info(info_flags::crational)) { return atan2_evalf(y,x); } return atan2(y,x).hold(); } static ex atan2_diff(ex const & y, ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param<2); if (diff_param==0) { // d/dy atan(y,x) return x*pow(pow(x,2)+pow(y,2),-1); } // d/dx atan(y,x) return -y*pow(pow(x,2)+pow(y,2),-1); } REGISTER_FUNCTION(atan2, atan2_eval, atan2_evalf, atan2_diff, NULL); ////////// // hyperbolic sine (trigonometric function) ////////// static ex sinh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(sinh(x)) return sinh(ex_to_numeric(x)); // -> numeric sinh(numeric) } static ex sinh_eval(ex const & x) { if (x.info(info_flags::numeric)) { if (x.is_zero()) // sinh(0) -> 0 return _ex0(); if (!x.info(info_flags::crational)) // sinh(float) -> float return sinh_evalf(x); } if ((x/Pi).info(info_flags::numeric) && ex_to_numeric(x/Pi).real().is_zero()) // sinh(I*x) -> I*sin(x) return I*sin(x/I); if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // sinh(asinh(x)) -> x if (is_ex_the_function(x, asinh)) return t; // sinh(acosh(x)) -> (x-1)^(1/2) * (x+1)^(1/2) if (is_ex_the_function(x, acosh)) return power(t-_ex1(),_ex1_2())*power(t+_ex1(),_ex1_2()); // sinh(atanh(x)) -> x*(1-x^2)^(-1/2) if (is_ex_the_function(x, atanh)) return t*power(_ex1()-power(t,_ex2()),_ex_1_2()); } return sinh(x).hold(); } static ex sinh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx sinh(x) -> cosh(x) return cosh(x); } REGISTER_FUNCTION(sinh, sinh_eval, sinh_evalf, sinh_diff, NULL); ////////// // hyperbolic cosine (trigonometric function) ////////// static ex cosh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(cosh(x)) return cosh(ex_to_numeric(x)); // -> numeric cosh(numeric) } static ex cosh_eval(ex const & x) { if (x.info(info_flags::numeric)) { if (x.is_zero()) // cosh(0) -> 1 return _ex1(); if (!x.info(info_flags::crational)) // cosh(float) -> float return cosh_evalf(x); } if ((x/Pi).info(info_flags::numeric) && ex_to_numeric(x/Pi).real().is_zero()) // cosh(I*x) -> cos(x) return cos(x/I); if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // cosh(acosh(x)) -> x if (is_ex_the_function(x, acosh)) return t; // cosh(asinh(x)) -> (1+x^2)^(1/2) if (is_ex_the_function(x, asinh)) return power(_ex1()+power(t,_ex2()),_ex1_2()); // cosh(atanh(x)) -> (1-x^2)^(-1/2) if (is_ex_the_function(x, atanh)) return power(_ex1()-power(t,_ex2()),_ex_1_2()); } return cosh(x).hold(); } static ex cosh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx cosh(x) -> sinh(x) return sinh(x); } REGISTER_FUNCTION(cosh, cosh_eval, cosh_evalf, cosh_diff, NULL); ////////// // hyperbolic tangent (trigonometric function) ////////// static ex tanh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(tanh(x)) return tanh(ex_to_numeric(x)); // -> numeric tanh(numeric) } static ex tanh_eval(ex const & x) { if (x.info(info_flags::numeric)) { if (x.is_zero()) // tanh(0) -> 0 return _ex0(); if (!x.info(info_flags::crational)) // tanh(float) -> float return tanh_evalf(x); } if ((x/Pi).info(info_flags::numeric) && ex_to_numeric(x/Pi).real().is_zero()) // tanh(I*x) -> I*tan(x); return I*tan(x/I); if (is_ex_exactly_of_type(x, function)) { ex t=x.op(0); // tanh(atanh(x)) -> x if (is_ex_the_function(x, atanh)) return t; // tanh(asinh(x)) -> x*(1+x^2)^(-1/2) if (is_ex_the_function(x, asinh)) return t*power(_ex1()+power(t,_ex2()),_ex_1_2()); // tanh(acosh(x)) -> (x-1)^(1/2)*(x+1)^(1/2)/x if (is_ex_the_function(x, acosh)) return power(t-_ex1(),_ex1_2())*power(t+_ex1(),_ex1_2())*power(t,_ex_1()); } return tanh(x).hold(); } static ex tanh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx tanh(x) -> 1-tanh(x)^2 return _ex1()-power(tanh(x),_ex2()); } static ex tanh_series(ex const & x, symbol const & s, ex const & point, int order) { // method: // Taylor series where there is no pole falls back to tanh_diff. // On a pole simply expand sinh(x)/cosh(x). ex xpoint = x.subs(s==point); if (!(2*I*xpoint/Pi).info(info_flags::odd)) throw do_taylor(); // caught by function::series() // if we got here we have to care for a simple pole return (sinh(x)/cosh(x)).series(s, point, order+2); } REGISTER_FUNCTION(tanh, tanh_eval, tanh_evalf, tanh_diff, tanh_series); ////////// // inverse hyperbolic sine (trigonometric function) ////////// static ex asinh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(asinh(x)) return asinh(ex_to_numeric(x)); // -> numeric asinh(numeric) } static ex asinh_eval(ex const & x) { if (x.info(info_flags::numeric)) { // asinh(0) -> 0 if (x.is_zero()) return _ex0(); // asinh(float) -> float if (!x.info(info_flags::crational)) return asinh_evalf(x); } return asinh(x).hold(); } static ex asinh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx asinh(x) -> 1/sqrt(1+x^2) return power(1+power(x,_ex2()),_ex_1_2()); } REGISTER_FUNCTION(asinh, asinh_eval, asinh_evalf, asinh_diff, NULL); ////////// // inverse hyperbolic cosine (trigonometric function) ////////// static ex acosh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(acosh(x)) return acosh(ex_to_numeric(x)); // -> numeric acosh(numeric) } static ex acosh_eval(ex const & x) { if (x.info(info_flags::numeric)) { // acosh(0) -> Pi*I/2 if (x.is_zero()) return Pi*I*numeric(1,2); // acosh(1) -> 0 if (x.is_equal(_ex1())) return _ex0(); // acosh(-1) -> Pi*I if (x.is_equal(_ex_1())) return Pi*I; // acosh(float) -> float if (!x.info(info_flags::crational)) return acosh_evalf(x); } return acosh(x).hold(); } static ex acosh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx acosh(x) -> 1/(sqrt(x-1)*sqrt(x+1)) return power(x+_ex_1(),_ex_1_2())*power(x+_ex1(),_ex_1_2()); } REGISTER_FUNCTION(acosh, acosh_eval, acosh_evalf, acosh_diff, NULL); ////////// // inverse hyperbolic tangent (trigonometric function) ////////// static ex atanh_evalf(ex const & x) { BEGIN_TYPECHECK TYPECHECK(x,numeric) END_TYPECHECK(atanh(x)) return atanh(ex_to_numeric(x)); // -> numeric atanh(numeric) } static ex atanh_eval(ex const & x) { if (x.info(info_flags::numeric)) { // atanh(0) -> 0 if (x.is_zero()) return _ex0(); // atanh({+|-}1) -> throw if (x.is_equal(_ex1()) || x.is_equal(_ex1())) throw (std::domain_error("atanh_eval(): infinity")); // atanh(float) -> float if (!x.info(info_flags::crational)) return atanh_evalf(x); } return atanh(x).hold(); } static ex atanh_diff(ex const & x, unsigned diff_param) { GINAC_ASSERT(diff_param==0); // d/dx atanh(x) -> 1/(1-x^2) return power(_ex1()-power(x,_ex2()),_ex_1()); } REGISTER_FUNCTION(atanh, atanh_eval, atanh_evalf, atanh_diff, NULL); #ifndef NO_GINAC_NAMESPACE } // namespace GiNaC #endif // ndef NO_GINAC_NAMESPACE