X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=check%2Fexam_paranoia.cpp;h=7977bd2e88f5440990f2c4b389237f726a0cb1f3;hp=b5ae9baf416ccc573411c27fb5487a3db98eea6e;hb=d4ea19a525805e98ddbc8c88a4bb229763373c04;hpb=6d225ee55693c0617d254e6fa283c00c71bd2919 diff --git a/check/exam_paranoia.cpp b/check/exam_paranoia.cpp index b5ae9baf..7977bd2e 100644 --- a/check/exam_paranoia.cpp +++ b/check/exam_paranoia.cpp @@ -1,12 +1,12 @@ /** @file exam_paranoia.cpp * * This set of tests checks for some of GiNaC's oopses which showed up during - * development. Things were evaluated wrongly and so. Such a sick behaviour + * development. Things were evaluated wrongly and so. Such a sick behavior * shouldn't occur any more. But we are paranoic and we want to exclude these * these oopses for good, so we run those stupid tests... */ /* - * GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2020 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 @@ -20,10 +20,14 @@ * * 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; + +#include +using namespace std; // The very first pair of historic problems had its roots in power.cpp and was // finally resolved on April 27th 1999. (Fixing the first on April 23rd @@ -69,23 +73,10 @@ static unsigned exam_paranoia2() f = e*y; g = f - e*y; - // After .expand(), g should be zero: - if (!g.expand().is_zero()) { - clog << "e = (x + z*x); f = e*y; expand(f - e*y) erroneously returned " - << g.expand() << endl; - ++result; - } // After .eval(), g should be zero: - if (!g.eval().is_zero()) { - clog << "e = (x + z*x); f = e*y; eval(f - e*y) erroneously returned " - << g.eval() << endl; - ++result; - } - // This actually worked already back in April 1999. - // But we are *very* paranoic! - if (!g.expand().eval().is_zero()) { - clog << "e = (x + z*x); f = e*y; eval(expand(f - e*y)) erroneously returned " - << g.expand().eval() << endl; + if (!g.is_zero()) { + clog << "e = (x + z*x); f = e*y; g = (f - e*y) erroneously returned g == " + << g << endl; ++result; } @@ -109,16 +100,6 @@ static unsigned exam_paranoia3() << f << endl; ++result; } - if (!f.eval().is_equal(y)) { - clog << "e = x*y - y; eval(e.subs(x == 2)) erroneously returned " - << f.eval() << endl; - ++result; - } - if (!f.expand().is_equal(y)) { - clog << "e = x*y - y; expand(e.subs(x == 2)) erroneously returned " - << f.expand() << endl; - ++result; - } return result; } @@ -139,11 +120,6 @@ static unsigned exam_paranoia4() << g << endl; ++result; } - if (!g.is_zero()) { - clog << "e = pow(x,2) + x + 1; f = pow(x,2) + x + 1; g = e-f; g.eval() erroneously returned " - << g.eval() << endl; - ++result; - } return result; } @@ -260,7 +236,7 @@ static unsigned exam_paranoia10() ex r; try { - r = pow(b,e).eval(); + r = pow(b, e); if (!(r-2*sqrt(ex(2))).is_zero()) { clog << "2^(3/2) erroneously returned " << r << " instead of 2*sqrt(2)" << endl; ++result; @@ -283,7 +259,7 @@ static unsigned exam_paranoia11() ex e = ((-5-2*x)-((2-5*x)/(-2+x))*(3+2*x))/(5-4*x); ex f = e.normal(); - ex d = (4+10*x+8*pow(x,2))/(x-2)/(5-4*x); + ex d = normal((4+10*x+8*pow(x,2))/(x-2)/(5-4*x)); if (!(f - d).expand().is_zero()) { clog << "normal(" << e << ") returns " << f << " instead of " << d << endl; @@ -437,12 +413,282 @@ static unsigned exam_paranoia16() return result; } +// Bug in reposition_dummy_indices() could result in correct expression +// turned into one with inconsistent indices. Fixed on Aug 29, 2006 +static unsigned exam_paranoia17() +{ + varidx mu1(symbol("mu1"), 4); + varidx mu2(symbol("mu2"), 4); + varidx mu3(symbol("mu3"), 4); + varidx mu4(symbol("mu4"), 4); + varidx mu5(symbol("mu5"), 4); + varidx mu6(symbol("mu6"), 4); + + exvector ev2; + ev2.push_back(mu3.toggle_variance()); + ev2.push_back(mu6); + ev2.push_back(mu5.toggle_variance()); + ev2.push_back(mu6.toggle_variance()); + ev2.push_back(mu5); + ev2.push_back(mu3); + // notice: all indices are contracted ... + + ex test_cycl = indexed(symbol("A"), sy_cycl(), ev2); + test_cycl = test_cycl.simplify_indexed(); + // ... so there should be zero free indices in the end. + return test_cycl.get_free_indices().size(); +} + +// Bug in add::eval() could result in numeric terms not being collected into +// the overall coefficient. Fixed first on Sep 22, 2010 and again on Dec 17 2015 +static unsigned exam_paranoia18() +{ + unsigned result = 0; + + ex sqrt2 = sqrt(ex(2)); + ex e1 = 1 + 2*(sqrt2+1)*(sqrt2-1); + if (e1.real_part() != 3) { + clog << "real_part(1+2*(sqrt(2)+1)*(sqrt(2)-1)) failed to evaluate to 3\n"; + ++result; + } + + ex sqrt3 = sqrt(ex(3)); + ex e2 = 2 + 2*(sqrt2+1)*(sqrt2-1) - 2*(sqrt3+1)*(sqrt3-1); + if (e2.real_part() != 0) { + clog << "real_part(2+2*(sqrt(2)+1)*(sqrt(2)-1)-3*(sqrt(3)+1)*(sqrt(3)-1)) failed to evaluate to 0\n"; + ++result; + } + + return result; +} + +// Bug in mul::conjugate when factors are evaluated at branch cuts, reported as +// Sage bug #10964. +static unsigned exam_paranoia19() +{ + symbol a("a"); + ex e = conjugate(a*sqrt(ex(-2))*sqrt(ex(-3))); + ex c = a*conjugate(sqrt(ex(-2)))*conjugate(sqrt(ex(-3))); + if (!subs(e-c, a==42).is_zero()) { + clog << "subs(a*conjugate(sqrt(-2))*conjugate(sqrt(-3))-conjugate(a*sqrt(-2)*sqrt(-3)),a==42) failed to evaluate to 0\n"; + return 1; + } + return 0; +} + +// Bugs in is_polynomial (fixed 2011-05-20 and 2014-07-26). +static unsigned exam_paranoia20() +{ + unsigned result = 0; + symbol x("x"), y("y"); + ex e1 = sqrt(x*x+1)*sqrt(x+1); + if (e1.is_polynomial(x)) { + clog << "sqrt(x*x+1)*sqrt(x+1) is wrongly reported to be a polynomial in x\n"; + ++result; + } + ex e2 = sqrt(Pi)*x; + if (!e2.is_polynomial(x)) { + clog << "sqrt(Pi)*x is wrongly reported to be no polynomial in x\n"; + ++result; + } + ex e3 = sqrt(x); + if (!e3.is_polynomial(y)) { + clog << "sqrt(x) is wrongly reported to be no polynomial in y\n"; + ++result; + } + ex e4 = (1+y)/(2+x); + if (e4.is_polynomial(x)) { + clog << "(1+y)/(2+x) is wrongly reported to be a polynomial in x\n"; + ++result; + } + return result; +} + +static unsigned exam_mul_info() +{ + symbol x("x"), y("y"); + ex e = x*y; + if (!e.info(info_flags::indefinite)) { + clog << "eek, product of two symbols is NOT indefinite\n"; + return 1; + } + return 0; +} + +static unsigned is_polynomial_false_positive() +{ + unsigned result = 0; + symbol x("x"), n("n"); + exvector nonpoly_exprs; + nonpoly_exprs.push_back(1/(1-x)); + nonpoly_exprs.push_back(1/(x+1)); + nonpoly_exprs.push_back(-1/(x-1)); + nonpoly_exprs.push_back(1/(1-x*x)); + nonpoly_exprs.push_back(1/(1-pow(x,n))); + nonpoly_exprs.push_back(x-1/(x-1)); + for (exvector::const_iterator ep = nonpoly_exprs.begin(); + ep != nonpoly_exprs.end(); ++ep) { + if (ep->is_polynomial(x)) { + clog << "(" << *ep << ").is_polynomial(" << x << ") " + "erroneously returned true" << endl; + ++result; + } + } + return result; +} + +// Bug in power::expand reported by Isuru Fernando (fixed 2015-05-07). +static unsigned exam_paranoia21() +{ + symbol x("x"); + ex e = pow(x + sqrt(ex(2))*x, 2).expand(); + if (e.nops() != 2) { + clog << "(x+sqrt(2)*x)^2 was wrongly expanded to " << e << "\n"; + return 1; + } + return 0; +} + +// Bug in power::expand (fixed 2015-07-18). +static unsigned exam_paranoia22() +{ + symbol x("x"), y("y"); + ex e = pow(sqrt(1+x)+y*sqrt(1+x), 2).expand(); + if (e.nops() != 6) { + clog << "(sqrt(1+x)+y*sqrt(1+x))^2 was wrongly expanded to " << e << "\n"; + return 1; + } + return 0; +} + +// Bug in expairseq::evalchildren(). +static unsigned exam_paranoia23() +{ + unsigned result = 0; + symbol x("x"); + + epvector v1; + v1.push_back(expair(1, 1)); + v1.push_back(expair(2*x, -1)); + ex e1 = add(v1); // Should be e==1-2*x, + if (!e1.is_equal(1-2*x)) { + clog << "Failure constructing " << e1 << " from add.\n"; + ++result; + } + + epvector v2; + v2.push_back(expair(x, 1)); + v2.push_back(expair(1,-1)); + ex e2 = mul(v2); // Should be e==x; + if (!e2.is_equal(x)) { + clog << "Failure constructing " << e2 << " from mul.\n"; + ++result; + } + + return result; +} + +// Bug in sqrfree_yun (fixed 2016-02-02). +static unsigned exam_paranoia24() +{ + unsigned result = 0; + symbol x("x"); + ex e; + + e = (x-1)*(x+1) - x*x + 1; // an unexpanded 0... + try { + ex f = sqrfree(e); + if (!f.is_zero()) { + clog << "sqrfree(" << e << ") returns " << f << " instead of 0\n"; + ++result; + } + } catch (const exception &err) { + clog << "sqrfree(" << e << ") throws " << err.what() << endl; + ++result; + } + + e = pow(x-1,3) - expand(pow(x-1,3)); // ...still after differentiating... + try { + ex f = sqrfree(e); + if (!f.is_zero()) { + clog << "sqrfree(" << e << ") returns " << f << " instead of 0\n"; + ++result; + } + } catch (const exception &err) { + clog << "sqrfree(" << e << ") throws " << err.what() << endl; + ++result; + } + + e = pow(x-1,4) - expand(pow(x-1,4)); // ...and after differentiating twice. + try { + ex f = sqrfree(e); + if (!f.is_zero()) { + clog << "sqrfree(" << e << ") returns " << f << " instead of 0\n"; + ++result; + } + } catch (const exception &err) { + clog << "sqrfree(" << e << ") throws " << err.what() << endl; + ++result; + } + + return result; +} + +// Bug in add ctor +unsigned exam_paranoia25() +{ + symbol a("a"), b("b"), c("c"); + ex e = -a + 2*b + c; + + if (e.diff(c).nops() > 1) { + clog << "diff(" << e << ",c) was not fully evaluated.\n"; + return 1; + } + return 0; +} + +// Bug in partial fraction expansion +unsigned exam_paranoia26() +{ + symbol x("x"); + ex ex1=pow(x,4)/(x-1)/4; + ex ex2=sqrfree_parfrac(ex1,x); + ex e = (ex1-ex2).normal(); + + if (! e.is_zero()) { + clog << "partial fraction expansion of " << ex1 << " produces error.\n"; + return 1; + } + return 0; +} + +// Bug in power expansion +unsigned exam_paranoia27() +{ + unsigned result = 0; + symbol x("x"), y("y"), a("a"); + possymbol s("s"), t("t"); + exmap pwrs = + { {pow((x+1)*(y-2)*(s-3)*(t+4), a), pow((x+1)*(y-2)*(s-3), a)*pow(t+4, a)}, + {pow(2*(x+1)*(y-2)*(s-3)*(t+4), a), pow(2,a)*pow((x+1)*(y-2)*(s-3), a)*pow(t+4, a)}, + {pow(-(x+1)*(y-2)*(s-3)*(t+4), a), pow(-(x+1)*(y-2)*(s-3), a)*pow(t+4, a)}, + {pow(-2*(x+1)*(y-2)*(s-3)*(t+4), a), pow(2,a)*pow(-(x+1)*(y-2)*(s-3), a)*pow(t+4, a)} }; + + for (auto e : pwrs) { + if (! (e.first.expand()).is_equal(e.second) ) { + clog << "power expansion of " << e.first << " produces error.\n"; + ++result; + } + } + + return result; +} + unsigned exam_paranoia() { unsigned result = 0; cout << "examining several historic failures just out of paranoia" << flush; - clog << "----------several historic failures:" << endl; result += exam_paranoia1(); cout << '.' << flush; result += exam_paranoia2(); cout << '.' << flush; @@ -460,13 +706,24 @@ unsigned exam_paranoia() result += exam_paranoia14(); cout << '.' << flush; result += exam_paranoia15(); cout << '.' << flush; result += exam_paranoia16(); cout << '.' << flush; - - if (!result) { - cout << " passed " << endl; - clog << "(no output)" << endl; - } else { - cout << " failed " << endl; - } + result += exam_paranoia17(); cout << '.' << flush; + result += exam_paranoia18(); cout << '.' << flush; + result += exam_paranoia19(); cout << '.' << flush; + result += exam_paranoia20(); cout << '.' << flush; + result += exam_mul_info(); cout << '.' << flush; + result += is_polynomial_false_positive(); cout << '.' << flush; + result += exam_paranoia21(); cout << '.' << flush; + result += exam_paranoia22(); cout << '.' << flush; + result += exam_paranoia23(); cout << '.' << flush; + result += exam_paranoia24(); cout << '.' << flush; + result += exam_paranoia25(); cout << '.' << flush; + result += exam_paranoia26(); cout << '.' << flush; + result += exam_paranoia27(); cout << '.' << flush; return result; } + +int main(int argc, char** argv) +{ + return exam_paranoia(); +}