X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=check%2Fexam_powerlaws.cpp;h=fb7328f55dfdc09e39764b25976391ece772cdcc;hp=c269e9747e93cb139333e17b9afac443abe1ecfc;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=383d5eb3b0f0506810d9105a268f939125bfc347 diff --git a/check/exam_powerlaws.cpp b/check/exam_powerlaws.cpp index c269e974..fb7328f5 100644 --- a/check/exam_powerlaws.cpp +++ b/check/exam_powerlaws.cpp @@ -4,7 +4,7 @@ * this code, it is a sanity check rather deeply rooted in GiNaC's classes. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2019 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 @@ -18,12 +18,16 @@ * * 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 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "exams.h" +#include "ginac.h" +using namespace GiNaC; -static unsigned exam_powerlaws1(void) +#include +using namespace std; + +static unsigned exam_powerlaws1() { // (x^a)^b = x^(a*b) @@ -32,11 +36,11 @@ static unsigned exam_powerlaws1(void) symbol b("b"); ex e1 = power(power(x,a), b); - if (!(is_ex_exactly_of_type(e1,power) && - is_ex_exactly_of_type(e1.op(0),power) && - is_ex_exactly_of_type(e1.op(0).op(0),symbol) && - is_ex_exactly_of_type(e1.op(0).op(1),symbol) && - is_ex_exactly_of_type(e1.op(1),symbol) && + if (!(is_exactly_a(e1) && + is_exactly_a(e1.op(0)) && + is_exactly_a(e1.op(0).op(0)) && + is_exactly_a(e1.op(0).op(1)) && + is_exactly_a(e1.op(1)) && e1.is_equal(power(power(x,a),b)) )) { clog << "(x^a)^b, x,a,b symbolic wrong" << endl; clog << "returned: " << e1 << endl; @@ -44,9 +48,9 @@ static unsigned exam_powerlaws1(void) } ex e2 = e1.subs(a==1); - if (!(is_ex_exactly_of_type(e2,power) && - is_ex_exactly_of_type(e2.op(0),symbol) && - is_ex_exactly_of_type(e2.op(1),symbol) && + if (!(is_exactly_a(e2) && + is_exactly_a(e2.op(0)) && + is_exactly_a(e2.op(1)) && e2.is_equal(power(x,b)) )) { clog << "(x^a)^b, x,b symbolic, a==1 wrong" << endl; clog << "returned: " << e2 << endl; @@ -54,43 +58,43 @@ static unsigned exam_powerlaws1(void) } ex e3 = e1.subs(a==-1); - if (!(is_ex_exactly_of_type(e3,power) && - is_ex_exactly_of_type(e3.op(0),power) && - is_ex_exactly_of_type(e3.op(0).op(0),symbol) && - is_ex_exactly_of_type(e3.op(0).op(1),numeric) && - is_ex_exactly_of_type(e3.op(1),symbol) && + if (!(is_exactly_a(e3) && + is_exactly_a(e3.op(0)) && + is_exactly_a(e3.op(0).op(0)) && + is_exactly_a(e3.op(0).op(1)) && + is_exactly_a(e3.op(1)) && e3.is_equal(power(power(x,-1),b)) )) { clog << "(x^a)^b, x,b symbolic, a==-1 wrong" << endl; clog << "returned: " << e3 << endl; return 1; } - ex e4 = e1.subs(lst(a==-1, b==2.5)); - if (!(is_ex_exactly_of_type(e4,power) && - is_ex_exactly_of_type(e4.op(0),power) && - is_ex_exactly_of_type(e4.op(0).op(0),symbol) && - is_ex_exactly_of_type(e4.op(0).op(1),numeric) && - is_ex_exactly_of_type(e4.op(1),numeric) && - e4.is_equal(power(power(x,-1),2.5)) )) { - clog << "(x^a)^b, x symbolic, a==-1, b==2.5 wrong" << endl; + ex e4 = e1.subs(lst{a==-1, b==-2.5}); + if (!(is_exactly_a(e4) && + is_exactly_a(e4.op(0)) && + is_exactly_a(e4.op(0).op(0)) && + is_exactly_a(e4.op(0).op(1)) && + is_exactly_a(e4.op(1)) && + e4.is_equal(power(power(x,-1),-2.5)) )) { + clog << "(x^a)^b, x symbolic, a==-1, b==-2.5 wrong" << endl; clog << "returned: " << e4 << endl; return 1; } - ex e5 = e1.subs(lst(a==-0.9, b==2.5)); - if (!(is_ex_exactly_of_type(e5,power) && - is_ex_exactly_of_type(e5.op(0),symbol) && - is_ex_exactly_of_type(e5.op(1),numeric) && + ex e5 = e1.subs(lst{a==-0.9, b==2.5}); + if (!(is_exactly_a(e5) && + is_exactly_a(e5.op(0)) && + is_exactly_a(e5.op(1)) && e5.is_equal(power(x,numeric(-0.9)*numeric(2.5))) )) { clog << "(x^a)^b, x symbolic, a==-0.9, b==2.5 wrong" << endl; clog << "returned: " << e5 << endl; return 1; } - ex e6 = e1.subs(lst(a==numeric(3)+numeric(5.3)*I, b==-5)); - if (!(is_ex_exactly_of_type(e6,power) && - is_ex_exactly_of_type(e6.op(0),symbol) && - is_ex_exactly_of_type(e6.op(1),numeric) && + ex e6 = e1.subs(lst{a==numeric(3)+numeric(5.3)*I, b==-5}); + if (!(is_exactly_a(e6) && + is_exactly_a(e6.op(0)) && + is_exactly_a(e6.op(1)) && e6.is_equal(power(x,numeric(-15)+numeric(5.3)*numeric(-5)*I)) )) { clog << "(x^a)^b, x symbolic, a==3+5.3*I, b==-5 wrong" << endl; clog << "returned: " << e6 << endl; @@ -100,7 +104,7 @@ static unsigned exam_powerlaws1(void) return 0; } -static unsigned exam_powerlaws2(void) +static unsigned exam_powerlaws2() { // (a*x)^b = a^b * x^b @@ -109,12 +113,12 @@ static unsigned exam_powerlaws2(void) symbol b("b"); ex e1 = power(a*x,b); - if (!(is_ex_exactly_of_type(e1,power) && - is_ex_exactly_of_type(e1.op(0),mul) && + if (!(is_exactly_a(e1) && + is_exactly_a(e1.op(0)) && (e1.op(0).nops()==2) && - is_ex_exactly_of_type(e1.op(0).op(0),symbol) && - is_ex_exactly_of_type(e1.op(0).op(1),symbol) && - is_ex_exactly_of_type(e1.op(1),symbol) && + is_exactly_a(e1.op(0).op(0)) && + is_exactly_a(e1.op(0).op(1)) && + is_exactly_a(e1.op(1)) && e1.is_equal(power(a*x,b)) )) { clog << "(a*x)^b, x,a,b symbolic wrong" << endl; clog << "returned: " << e1 << endl; @@ -122,12 +126,12 @@ static unsigned exam_powerlaws2(void) } ex e2 = e1.subs(a==3); - if (!(is_ex_exactly_of_type(e2,power) && - is_ex_exactly_of_type(e2.op(0),mul) && + if (!(is_exactly_a(e2) && + is_exactly_a(e2.op(0)) && (e2.op(0).nops()==2) && - is_ex_exactly_of_type(e2.op(0).op(0),symbol) && - is_ex_exactly_of_type(e2.op(0).op(1),numeric) && - is_ex_exactly_of_type(e2.op(1),symbol) && + is_exactly_a(e2.op(0).op(0)) && + is_exactly_a(e2.op(0).op(1)) && + is_exactly_a(e2.op(1)) && e2.is_equal(power(3*x,b)) )) { clog << "(a*x)^b, x,b symbolic, a==3 wrong" << endl; clog << "returned: " << e2 << endl; @@ -135,10 +139,10 @@ static unsigned exam_powerlaws2(void) } ex e3 = e1.subs(b==-3); - if (!(is_ex_exactly_of_type(e3,mul) && + if (!(is_exactly_a(e3) && (e3.nops()==2) && - is_ex_exactly_of_type(e3.op(0),power) && - is_ex_exactly_of_type(e3.op(1),power) && + is_exactly_a(e3.op(0)) && + is_exactly_a(e3.op(1)) && e3.is_equal(power(a,-3)*power(x,-3)) )) { clog << "(a*x)^b, x,a symbolic, b==-3 wrong" << endl; clog << "returned: " << e3 << endl; @@ -146,23 +150,23 @@ static unsigned exam_powerlaws2(void) } ex e4 = e1.subs(b==4.5); - if (!(is_ex_exactly_of_type(e4,power) && - is_ex_exactly_of_type(e4.op(0),mul) && + if (!(is_exactly_a(e4) && + is_exactly_a(e4.op(0)) && (e4.op(0).nops()==2) && - is_ex_exactly_of_type(e4.op(0).op(0),symbol) && - is_ex_exactly_of_type(e4.op(0).op(1),symbol) && - is_ex_exactly_of_type(e4.op(1),numeric) && + is_exactly_a(e4.op(0).op(0)) && + is_exactly_a(e4.op(0).op(1)) && + is_exactly_a(e4.op(1)) && e4.is_equal(power(a*x,4.5)) )) { clog << "(a*x)^b, x,a symbolic, b==4.5 wrong" << endl; clog << "returned: " << e4 << endl; return 1; } - ex e5 = e1.subs(lst(a==3.2, b==3+numeric(5)*I)); - if (!(is_ex_exactly_of_type(e5,mul) && + ex e5 = e1.subs(lst{a==3.2, b==3+numeric(5)*I}); + if (!(is_exactly_a(e5) && (e5.nops()==2) && - is_ex_exactly_of_type(e5.op(0),power) && - is_ex_exactly_of_type(e5.op(1),numeric) && + is_exactly_a(e5.op(0)) && + is_exactly_a(e5.op(1)) && e5.is_equal(power(x,3+numeric(5)*I)* power(numeric(3.2),3+numeric(5)*I)) )) { clog << "(a*x)^b, x symbolic, a==3.2, b==3+5*I wrong" << endl; @@ -170,11 +174,11 @@ static unsigned exam_powerlaws2(void) return 1; } - ex e6 = e1.subs(lst(a==-3.2, b==3+numeric(5)*I)); - if (!(is_ex_exactly_of_type(e6,mul) && + ex e6 = e1.subs(lst{a==-3.2, b==3+numeric(5)*I}); + if (!(is_exactly_a(e6) && (e6.nops()==2) && - is_ex_exactly_of_type(e6.op(0),power) && - is_ex_exactly_of_type(e6.op(1),numeric) && + is_exactly_a(e6.op(0)) && + is_exactly_a(e6.op(1)) && e6.is_equal(power(-x,3+numeric(5)*I)* power(numeric(3.2),3+numeric(5)*I)) )) { clog << "(a*x)^b, x symbolic, a==-3.2, b==3+5*I wrong" << endl; @@ -182,13 +186,13 @@ static unsigned exam_powerlaws2(void) return 1; } - ex e7 = e1.subs(lst(a==3+numeric(5)*I, b==3.2)); - if (!(is_ex_exactly_of_type(e7,power) && - is_ex_exactly_of_type(e7.op(0),mul) && + ex e7 = e1.subs(lst{a==3+numeric(5)*I, b==3.2}); + if (!(is_exactly_a(e7) && + is_exactly_a(e7.op(0)) && (e7.op(0).nops()==2) && - is_ex_exactly_of_type(e7.op(0).op(0),symbol) && - is_ex_exactly_of_type(e7.op(0).op(1),numeric) && - is_ex_exactly_of_type(e7.op(1),numeric) && + is_exactly_a(e7.op(0).op(0)) && + is_exactly_a(e7.op(0).op(1)) && + is_exactly_a(e7.op(1)) && e7.is_equal(power((3+numeric(5)*I)*x,3.2)) )) { clog << "(a*x)^b, x symbolic, a==3+5*I, b==3.2 wrong" << endl; clog << "returned: " << e7 << endl; @@ -198,7 +202,7 @@ static unsigned exam_powerlaws2(void) return 0; } -static unsigned exam_powerlaws3(void) +static unsigned exam_powerlaws3() { // numeric evaluation @@ -215,7 +219,7 @@ static unsigned exam_powerlaws3(void) } ex e3 = power(numeric(5),numeric(1,2)); - if (!(is_ex_exactly_of_type(e3,power) && + if (!(is_exactly_a(e3) && e3.op(0).is_equal(numeric(5)) && e3.op(1).is_equal(numeric(1,2)))) { clog << "5^(1/2) wrongly returned " << e3 << endl; @@ -223,13 +227,13 @@ static unsigned exam_powerlaws3(void) } ex e4 = power(numeric(5),evalf(numeric(1,2))); - if (!(is_ex_exactly_of_type(e4,numeric))) { + if (!(is_exactly_a(e4))) { clog << "5^(0.5) wrongly returned " << e4 << endl; return 1; } ex e5 = power(evalf(numeric(5)),numeric(1,2)); - if (!(is_ex_exactly_of_type(e5,numeric))) { + if (!(is_exactly_a(e5))) { clog << "5.0^(1/2) wrongly returned " << e5 << endl; return 1; } @@ -237,7 +241,7 @@ static unsigned exam_powerlaws3(void) return 0; } -static unsigned exam_powerlaws4(void) +static unsigned exam_powerlaws4() { // test for mul::eval() @@ -262,7 +266,7 @@ static unsigned exam_powerlaws4(void) return 0; } -static unsigned exam_powerlaws5(void) +static unsigned exam_powerlaws5() { // cabinet of slightly pathological cases @@ -275,7 +279,7 @@ static unsigned exam_powerlaws5(void) } ex e2 = pow(0,a); - if (!(is_ex_exactly_of_type(e2,power))) { + if (!(is_exactly_a(e2))) { clog << "0^a was evaluated to " << e2 << " though nothing is known about a." << endl; return 1; @@ -284,25 +288,54 @@ static unsigned exam_powerlaws5(void) return 0; } -unsigned exam_powerlaws(void) +static unsigned exam_powerlaws6() +{ + // check expansion rules for positive symbols + + symbol a("a"); + symbol b("b"); + symbol c("c"); + realsymbol x("x"); + realsymbol y("y"); + possymbol p("p"); + possymbol q("q"); + numeric half=numeric(1,2); + + ex e1 = pow(5*pow(3*a*b*x*y*p*q,2),7*half*c).expand(); + ex e2 = pow(p,7*c)*pow(q,7*c)*pow(pow(a*b*x*y,2),numeric(7,2)*c)*pow(45,numeric(7,2)*c); + if (!e1.is_equal(e2)) { + clog << "Could not expand exponents with positive bases in " << e1 << endl; + return 1; + } + + ex e3 = pow(-pow(-a*x*p,3)*pow(b*y*p,3),half*c).expand().normal(); + ex e4 = pow(p,3*c)*pow(pow(a*b*x*y,3),half*c); + + if (!e3.is_equal(e4)) { + clog << "Could not expand exponents with positive bases in " << e3 << endl; + return 1; + } + + return 0; +} + +unsigned exam_powerlaws() { unsigned result = 0; cout << "examining power laws" << flush; - clog << "----------power laws:" << endl; result += exam_powerlaws1(); cout << '.' << flush; result += exam_powerlaws2(); cout << '.' << flush; result += exam_powerlaws3(); cout << '.' << flush; result += exam_powerlaws4(); cout << '.' << flush; result += exam_powerlaws5(); cout << '.' << flush; - - if (!result) { - cout << " passed " << endl; - clog << "(no output)" << endl; - } else { - cout << " failed " << endl; - } + result += exam_powerlaws6(); cout << '.' << flush; return result; } + +int main(int argc, char** argv) +{ + return exam_powerlaws(); +}