X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=check%2Finifcns_consist.cpp;h=650d69bbcc4fe16c22d90ebf893b23f6296d800e;hp=35baf29c078eb25750a31b2721bf1f17e3dc1b89;hb=8a3a0aad0fe18304062335fdc934757855abd887;hpb=5c0989497994b35faa9c17b18f936c21dbb22d78 diff --git a/check/inifcns_consist.cpp b/check/inifcns_consist.cpp index 35baf29c..650d69bb 100644 --- a/check/inifcns_consist.cpp +++ b/check/inifcns_consist.cpp @@ -1,9 +1,31 @@ -// check/inifcns_consist.cpp +/** @file inifcns_consist.cpp + * + * This test routine applies assorted tests on initially known higher level + * functions. */ -/* This test routine applies assorted tests on initially known higher level - * 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 "ginac.h" +#include + +#ifndef NO_GINAC_NAMESPACE +using namespace GiNaC; +#endif // ndef NO_GINAC_NAMESPACE /* Simple tests on the sine trigonometric function. */ static unsigned inifcns_consist_sin(void) @@ -14,11 +36,11 @@ static unsigned inifcns_consist_sin(void) // sin(n*Pi) == 0? errorflag = false; for (int n=-10; n<=10; ++n) { - if ( sin(n*Pi).eval() != numeric(0) || - !sin(n*Pi).eval().info(info_flags::integer) ) + if ( sin(n*Pi).eval() != numeric(0) || + !sin(n*Pi).eval().info(info_flags::integer)) errorflag = true; } - if ( errorflag ) { + if (errorflag) { clog << "sin(n*Pi) with integer n does not always return exact 0" << endl; ++result; @@ -27,12 +49,12 @@ static unsigned inifcns_consist_sin(void) // sin((n+1/2)*Pi) == {+|-}1? errorflag = false; for (int n=-10; n<=10; ++n) { - if ( ! sin((n+numeric(1,2))*Pi).eval().info(info_flags::integer) || - !(sin((n+numeric(1,2))*Pi).eval() == numeric(1) || - sin((n+numeric(1,2))*Pi).eval() == numeric(-1)) ) + if (! sin((n+numeric(1,2))*Pi).eval().info(info_flags::integer) || + !(sin((n+numeric(1,2))*Pi).eval() == numeric(1) || + sin((n+numeric(1,2))*Pi).eval() == numeric(-1))) errorflag = true; } - if ( errorflag ) { + if (errorflag) { clog << "sin((n+1/2)*Pi) with integer n does not always return exact {+|-}1" << endl; ++result; @@ -50,11 +72,11 @@ static unsigned inifcns_consist_cos(void) // cos((n+1/2)*Pi) == 0? errorflag = false; for (int n=-10; n<=10; ++n) { - if ( cos((n+numeric(1,2))*Pi).eval() != numeric(0) || - !cos((n+numeric(1,2))*Pi).eval().info(info_flags::integer) ) + if ( cos((n+numeric(1,2))*Pi).eval() != numeric(0) || + !cos((n+numeric(1,2))*Pi).eval().info(info_flags::integer)) errorflag = true; } - if ( errorflag ) { + if (errorflag) { clog << "cos((n+1/2)*Pi) with integer n does not always return exact 0" << endl; ++result; @@ -63,12 +85,12 @@ static unsigned inifcns_consist_cos(void) // cos(n*Pi) == 0? errorflag = false; for (int n=-10; n<=10; ++n) { - if ( ! cos(n*Pi).eval().info(info_flags::integer) || - !(cos(n*Pi).eval() == numeric(1) || - cos(n*Pi).eval() == numeric(-1)) ) + if (! cos(n*Pi).eval().info(info_flags::integer) || + !(cos(n*Pi).eval() == numeric(1) || + cos(n*Pi).eval() == numeric(-1))) errorflag = true; } - if ( errorflag ) { + if (errorflag) { clog << "cos(n*Pi) with integer n does not always return exact {+|-}1" << endl; ++result; @@ -147,46 +169,43 @@ static unsigned inifcns_consist_trans(void) return result; } -/* Simple tests on the Gamma combinatorial function. We stuff in arguments - * where the result exists in closed form and check if it's ok. */ +/* Simple tests on the Gamma function. We stuff in arguments where the results + * exists in closed form and check if it's ok. */ static unsigned inifcns_consist_gamma(void) { unsigned result = 0; ex e; e = gamma(ex(1)); - for (int i=2; i<8; ++i) { + for (int i=2; i<8; ++i) e += gamma(ex(i)); - } - if ( e != numeric(874) ) { + if (e != numeric(874)) { clog << "gamma(1)+...+gamma(7) erroneously returned " << e << " instead of 874" << endl; ++result; } e = gamma(ex(1)); - for (int i=2; i<8; ++i) { - e *= gamma(ex(i)); - } - if ( e != numeric(24883200) ) { + for (int i=2; i<8; ++i) + e *= gamma(ex(i)); + if (e != numeric(24883200)) { clog << "gamma(1)*...*gamma(7) erroneously returned " << e << " instead of 24883200" << endl; ++result; } - + e = gamma(ex(numeric(5, 2)))*gamma(ex(numeric(9, 2)))*64; - if ( e != 315*Pi ) { + if (e != 315*Pi) { clog << "64*gamma(5/2)*gamma(9/2) erroneously returned " << e << " instead of 315*Pi" << endl; ++result; } e = gamma(ex(numeric(-13, 2))); - for (int i=-13; i<7; i=i+2) { + for (int i=-13; i<7; i=i+2) e += gamma(ex(numeric(i, 2))); - } e = (e*gamma(ex(numeric(15, 2)))*numeric(512)); - if ( e != numeric(633935)*Pi ) { + if (e != numeric(633935)*Pi) { clog << "512*(gamma(-13/2)+...+gamma(5/2))*gamma(15/2) erroneously returned " << e << " instead of 633935*Pi" << endl; ++result; @@ -195,6 +214,55 @@ static unsigned inifcns_consist_gamma(void) return result; } +/* Simple tests on the Psi-function (aka polygamma-function). We stuff in + arguments where the result exists in closed form and check if it's ok. */ +static unsigned inifcns_consist_psi(void) +{ + unsigned result = 0; + symbol x; + ex e, f; + + // We check psi(1) and psi(1/2) implicitly by calculating the curious + // little identity gamma(1)'/gamma(1) - gamma(1/2)'/gamma(1/2) == 2*log(2). + e += (gamma(x).diff(x)/gamma(x)).subs(x==numeric(1)); + e -= (gamma(x).diff(x)/gamma(x)).subs(x==numeric(1,2)); + if (e!=2*log(2)) { + clog << "gamma(1)'/gamma(1) - gamma(1/2)'/gamma(1/2) erroneously returned " + << e << " instead of 2*log(2)" << endl; + ++result; + } + + return result; +} + +/* Simple tests on the Riemann Zeta function. We stuff in arguments where the + * result exists in closed form and check if it's ok. Of course, this checks + * the Bernoulli numbers as a side effect. */ +static unsigned inifcns_consist_zeta(void) +{ + unsigned result = 0; + ex e; + + for (int i=0; i<13; i+=2) + e += zeta(i)/pow(Pi,i); + if (e!=numeric(-204992279,638512875)) { + clog << "zeta(0) + zeta(2) + ... + zeta(12) erroneously returned " + << e << " instead of -204992279/638512875" << endl; + ++result; + } + + e = 0; + for (int i=-1; i>-16; i--) + e += zeta(i); + if (e!=numeric(487871,1633632)) { + clog << "zeta(-1) + zeta(-2) + ... + zeta(-15) erroneously returned " + << e << " instead of 487871/1633632" << endl; + ++result; + } + + return result; +} + unsigned inifcns_consist(void) { unsigned result = 0; @@ -206,8 +274,10 @@ unsigned inifcns_consist(void) result += inifcns_consist_cos(); result += inifcns_consist_trans(); result += inifcns_consist_gamma(); + result += inifcns_consist_psi(); + result += inifcns_consist_zeta(); - if ( !result ) { + if (!result) { cout << " passed "; clog << "(no output)" << endl; } else {