https://github.com/root-project/root
Tip revision: 77846449287b91237eeabb75432fa6358d1b0b08 authored by ferdymercury on 27 March 2024, 10:06:56 UTC
[hist] fix similar bug in TSpline5_saveas
[hist] fix similar bug in TSpline5_saveas
Tip revision: 7784644
TFormulaParsingTests.h
#include "TF1.h"
#include "TF2.h"
#include "TF3.h"
#include "TFormula.h"
#include "TGraph.h"
#include "TMath.h"
#include "Math/ChebyshevPol.h"
#include "TError.h"
#include "TFile.h"
#include "TMacro.h"
#include "TSystem.h"
#include <limits>
#include <cstdlib>
#include <stdio.h>
// test of tformula neeeded to be run
class TFormulaParsingTests {
bool verbose;
std::vector<int> failedTests;
// We need a softer way to reason about equality in 32 bits
// Being this a quick test, doing the check at runtime is really no problem.
bool fpEqual(double x, double y, bool epsilon = false)
{
bool isEqual = epsilon ? std::abs(x-y) <= std::numeric_limits<double>::epsilon() : x == y;
if (!isEqual) {
// std::hexfloat not there for older gcc versions
printf("\nThe numbers differ: %A and %A\n", x, y);
}
return isEqual;
}
public:
TFormulaParsingTests(bool _verbose = false) : verbose(_verbose) {}
bool test1() {
// test composition of functions
TF1 f1("f1","[0]+[1]*x*x");
TF1 f2("f2","[0]+[1]*f1");
f2.SetParameters(1,2,3,4);
return (f2.Eval(2) == 39.);
}
bool test2() {
TF1 f1("f1","[0]+[1]*x");
TF1 f2("f2","[0]+[1]*x*f1");
TF1 f3("f3",f2.GetExpFormula() );
f3.SetParameters(1,2,3,4);
return (f3.Eval(2) == 45.);
}
bool test3() {
// still tets composition of functions
TF1 f1("f1","gaus");
TF1 f2("f2","[0]+[1]*x+f1");
f2.SetParameters(10,2,5,2,1);
f1.SetParameters(5,2,1);
return (f2.Eval(2) == (10. + 2*2 + f1.Eval(2)) );
}
bool test4() {
// similar but with different name (it contains gaus)
TF1 f1("fgaus","gaus");
TF1 f2("f2","[0]+[1]*x+fgaus");
f2.SetParameters(10,2,5,2,1);
f1.SetParameters(5,2,1);
return (f2.Eval(2) == (10. + 2*2 + f1.Eval(2)) );
}
bool test5() {
// similar but with different name (it contains gaus)
TF1 f1("gausnfunc","gaus");
TF1 f2("f2","[0]+[1]*x+gausnfunc");
f2.SetParameters(10,2,5,2,1);
f1.SetParameters(5,2,1);
return (f2.Eval(2) == (10. + 2*2 + f1.Eval(2)) );
}
bool test1a() {
// this makes infinite loop
// why re-using same name
TF1 f1("f1","[0]+[1]*x*x");
TF1 f2("f1","[0]+[1]*f1");
return true;
}
bool test6() {
// test linear function used in fitting
bool ok = true;
double x[] = {1,2,3,4,5};
double y[] = {1,4,7,9,10};
TGraph g(5,x,y);
int iret = g.Fit("x++1","Q");
ok &= (iret == 0);
iret = g.Fit("1++x","Q");
ok &= (iret == 0);
return ok;
}
bool test7() {
// test copying and deleting of linear functions
TF1 * f1 = new TF1("f1","1++x");
if (f1->GetNpar() != 2) return false;
f1->SetParameters(2,3);
if (f1->Eval(3) != 11) return false;
if (verbose) printf("Test7: test linear part1 of function\n");
TFormula * lin1 = (TFormula*) f1->GetLinearPart(1);
assert (lin1);
if (lin1->Eval(3) != 3) return false;
if (verbose) printf("Test7: test copying linear function\n");
TF1 * f2 = new TF1(*f1);
if (f2->Eval(3) != 11) return false;
if (verbose) printf("Test7: test linear part1 of copied function\n");
if (!f2->IsLinear()) return false;
lin1 = (TFormula*) f2->GetLinearPart(1);
assert (lin1);
if (lin1->Eval(3) != 3) return false;
delete f1;
if (verbose) printf("Test7: test cloning linear function\n");
TF1 * f3 = (TF1*) f2->Clone("f3");
if (f3->Eval(3) != 11) return false;
if (verbose) printf("Test7: test deleting the copied function\n");
delete f2;
if (verbose) printf("Test7: test linear part1 of cloned function\n");
if (!f3->IsLinear()) return false;
lin1 = (TFormula*) f3->GetLinearPart(1);
assert (lin1);
if (verbose) printf("Test7: test evaluating linear part1 of cloned function\n");
if (lin1->Eval(3) != 3) return false;
if (verbose) printf("Test7: test deleting the cloned function\n");
delete f3;
return true;
}
bool test8() {
// test the operator ^
bool ok = true;
TFormula * f = 0;
f = new TFormula("f","x^y");
ok &= (f->Eval(2,3) == 8);
delete f;
f = new TFormula("f","(x+[0])^y");
f->SetParameter(0,1);
ok &= (f->Eval(2,3) == 27);
delete f;
f = new TFormula("f","sqrt(x+[0])^y");
f->SetParameter(0,2);
ok &= (f->Eval(2,3) == 8);
delete f;
f = new TFormula("f","[0]/((x+2)^y)");
f->SetParameter(0,27);
ok &= (f->Eval(1,3) == 1);
delete f;
f = new TFormula("f","[0]/((x+2)^(y+1))");
f->SetParameter(0,27);
ok &= (f->Eval(1,2) == 1);
delete f;
// test also nested operators
f = new TFormula("f","((x+1)^y)^z");
ok &= (f->Eval(1,3,4) == 4096);
delete f;
f = new TFormula("f","x^((y+1)^z)");
ok &= (f->Eval(2,1,3) == 256);
delete f;
return ok;
}
bool test9() {
// test the exponent notations in numbers
bool ok = true;
TFormula * f = 0;
f = new TFormula("f","x+2.0e1");
ok &= (f->Eval(1) == 21.);
f = new TFormula("f","x*2.e-1");
ok &= (f->Eval(10) == 2.);
f = new TFormula("f","x*2.e+1");
ok &= (f->Eval(0.1) == 2.);
f = new TFormula("f","x*2E2");
ok &= (f->Eval(0.01) == 2.);
delete f;
return ok;
}
bool test10() {
// test the operator "? : "
bool ok = true;
TFormula * f = 0;
f = new TFormula("f","(x<0)?-x:x");
ok &= (f->Eval(-2) == 2);
ok &= (f->Eval(2) == 2);
f = new TFormula("f","(x<0)?x:pol2");
f->SetParameters(1,2,3);
ok &= (f->Eval(-2) == -2);
ok &= (f->Eval(2) == 1 + 2*2 + 2*2*3);
delete f;
return ok;
}
bool test11() {
// test with ::
bool ok = true;
TFormula f1("f","ROOT::Math::normal_pdf(x,1,2)");
TFormula f2("f","[0]+TMath::Gaus(x,2,1,true)");
f2.SetParameter(0,1);
ok &= ( (f1.Eval(2) +1. ) == f2.Eval(2) );
return ok;
}
bool test12() {
// test parameters order
bool ok = true;
TFormula * f = 0;
f = new TFormula("f","[2] + [3]*x + [0]*x^2 + [1]*x^3");
f->SetParameters(1,2,3,4);
double result = 3+4*2+1*4+2*8;
ok &= (f->Eval(2) == result);
f = new TFormula("f","[b] + [c]*x + [d]*x^2 + [a]*x^3");
f->SetParameters(1,2,3,4);
result = 2+3*2+4*4+1*8;
ok &= (f->Eval(2) == result);
// change a parameter value
f->SetParName(2,"par2");
ok &= (f->Eval(2) == result);
return ok;
}
bool test13() {
// test GetExpFormula
TFormula f("f","[2] + [0]*x + [1]*x*x");
f.SetParameters(1,2,3);
return (f.GetExpFormula() == TString("[p2]+[p0]*x+[p1]*x*x"));
}
bool test14() {
// test GetExpFormula
TFormula f("f","[2] + [0]*x + [1]*x*x");
f.SetParameters(1,2,3);
return (f.GetExpFormula("P") == TString("3+1*x+2*x*x"));
}
bool test15() {
// test GetExpFormula
TFormula f("f","[2] + [0]*x + [1]*x*x");
f.SetParameters(1,2,3);
return (f.GetExpFormula("CLING") == TString("p[2]+p[0]*x[0]+p[1]*x[0]*x[0] ") ); // need an extra white space
}
bool test16() {
// test GetExpFormula
TFormula f("f","[2] + [0]*x + [1]*x*x");
f.SetParameters(1,2,3);
return (f.GetExpFormula("CLING P") == TString("3.000000+1.000000*x[0]+2.000000*x[0]*x[0] ") );
}
bool test17() {
// test Eval for TF1
TF1 * f1 = new TF1("f1","[0]*sin([1]*x)");
f1->SetParameters(2,3);
TF1 * f0 = new TF1("f0",[](double *x, double *p){ return p[0]*sin(p[1]*x[0]); },0,10,2);
f0->SetParameters(2,3);
bool ok = true;
ok &= fpEqual(f1->Eval(1.5) , f0->Eval(1.5) );
double xx[1] = {2.5};
ok &= fpEqual(f1->EvalPar(xx) , f0->Eval(2.5) );
return ok;
}
bool test18() {
// test Eval for TF2
TF2 * f1 = new TF2("f2","[0]*sin([1]*x*y)");
f1->SetParameters(2,3);
TF2 * f0 = new TF2("f0",[](double *x, double *p){ return p[0]*sin(p[1]*x[0]*x[1]); },0,10,0,10,2);
f0->SetParameters(2,3);
bool ok = true;
ok &= fpEqual(f1->Eval(1.5,2.5) , f0->Eval(1.5,2.5) );
double par[2] = {3,4};
double xx[2] = {0.8,1.6};
ok &= fpEqual(f1->EvalPar(xx,par) , f0->EvalPar(xx,par) );
return ok;
}
bool test19() {
// test Eval for TF3
TF3 * f1 = new TF3("f3","[0]*sin([1]*x*y*z)");
f1->SetParameters(2,3);
TF3 * f0 = new TF3("f0",[](double *x, double *p){ return p[0]*sin(p[1]*x[0]*x[1]*x[2]); },0,10,0,10,0,10,2);
f0->SetParameters(2,3);
bool ok = true;
ok &= fpEqual(f1->Eval(1.5,2.5,3.5) , f0->Eval(1.5,2.5,3.5) );
double par[2] = {3,4};
double xx[3] = {0.8,1.6,2.2};
ok &= fpEqual(f1->EvalPar(xx,par) , f0->EvalPar(xx,par) );
return ok;
}
bool test20() {
// test parameter order with more than 10 parameters
TF2 f2("f2","xygaus+xygaus(5)+xygaus(10)+[offset]");
double params[16] = {1,0,1,1,1, 2,-1,2,0,2, 2,1,3,-1,2, 10};
f2.SetParameters(params);
TF2 f0("f2",[](double *x, double *p){ return p[0]*TMath::Gaus(x[0],p[1],p[2])*TMath::Gaus(x[1],p[3],p[4]) +
p[5]*TMath::Gaus(x[0],p[6],p[7])*TMath::Gaus(x[1],p[8],p[9]) +
p[10]*TMath::Gaus(x[0],p[11],p[12])*TMath::Gaus(x[1],p[13],p[14]) + p[15]; },
-10,10,-10,10,16);
double xx[2]={1,2};
//printf(" difference = %f , value %f \n", f2.Eval(1,2) - f0.EvalPar(xx,params), f2.Eval(1,2) );
return fpEqual( f2.Eval(1,2) , f0.EvalPar(xx,params) );
}
bool test21() {
// test parsing polynomials (bug ROOT-7312)
TFormula f("f","pol2+gaus(3)");
f.SetParameters(1,2,3,1,0,1);
TF1 f0("f0",[](double *x, double *p){ return p[0]+x[0]*p[1]+x[0]*x[0]*p[2]+p[3]*TMath::Gaus(x[0],p[4],p[5]); },0,1,6);
f0.SetParameters(f.GetParameters() );
return fpEqual(f.Eval(2) , f0.Eval(2) );
}
bool test22() {
// test chebyshev
TF1 f("f","cheb10+[offset]");
double p[12] = {1,1,1,1,1,1,1,1,1,1,1,10 };
f.SetParameters(p);
return (f.Eval(0.5) == ROOT::Math::ChebyshevN(10, 0.5, p ) + f.GetParameter("offset"));
}
bool test23() {
// fix function compositions using pre-defined functions
bool ok = true;
TF1 f1("f1","gaus");
TF1 f2("f2","[0]+f1");
TF1 f0("f0",[](double *x, double *p){ return p[0]+p[1]*TMath::Gaus(x[0],p[2],p[3]); },-3,3,4 );
f2.SetParameters(10,1,0,1);
f0.SetParameters(f2.GetParameters() );
ok &= fpEqual(f2.Eval(1) , f0.Eval(1) );
TF1 f3("f3","f1+[0]");
// param order should be the same
f3.SetParameters( f2.GetParameters() );
ok &= fpEqual(f3.Eval(1) , f0.Eval(1) );
return ok;
}
bool test24() {
// test I/O for parameter ordering
bool ok = true;
TF2 f("f","xygaus");
f.SetParameters(10,0,1,-1,2);
TF2 * f2 = (TF2*) f.Clone();
ok &= ( f.Eval(1,1) == f2->Eval(1,1) );
// test with copy
TF2 f3(f);
ok &= ( f.Eval(1,1) == f3.Eval(1,1) );
return ok;
}
bool test25() {
// fix parsing of operator^ (ROOT-7349)
bool ok = true;
TF1 f1("f1","x^-2.5");
ok &= (f1.Eval(3.) == TMath::Power(3,-2.5) );
if (!ok) std::cout << "Error in test25 - f != x^-2.5 " << f1.Eval(3.) << " " << TMath::Power(3,-2.5) << std::endl;
TF1 f2("f2","x^+2.5");
//TF1 f3("f3","std::pow(x,2.5)"); // this needed to be fixed
TF1 f3("f3","TMath::Power(x,2.5)");
bool ret = (f2.Eval(3.) == f3.Eval(3) );
if (!ret) std::cout << "Error in test25 - f2 != f3 " << f2.Eval(3.) << " " << f3.Eval(3.) << std::endl;
ok &= ret;
//cms test
TF1 t1("t1","(x<190)?(-18.7813+(((2.49368+(10.3321/(x^0.881126)))*exp(-((x^-1.66603)/0.074916)))-(-17.5757*exp(-((x^-1464.26)/-7.94004e+06))))):(1.09984+(0.394544*exp(-(x/562.407))))");
double x = 2;
double y =(x<190)?(-18.7813+(((2.49368+(10.3321/(std::pow(x,0.881126))))*exp(-((std::pow(x,-1.66603))/0.074916)))-(-17.5757*exp(-((std::pow(x,-1464.26))/-7.94004e+06))))):(1.09984+(0.394544*exp(-(x/562.407))));
// this fails on 32 bits - put a tolerance
ret = TMath::AreEqualAbs(t1.Eval(2) , y , 1.E-8);
if (!ret) std::cout << "Error in test25 - t1 != y " << t1.Eval(2.) << " " << y << std::endl;
ok &= ret;
// tests with scientific notations
auto ff = new TFormula("ff","x+2.e-2^1.2e-1");
ret = ( ff->Eval(1.) == (1. + std::pow(2.e-2,1.2e-1) ) );
if (!ret) std::cout << "Error in test25 - ff != expr " << ff->Eval(1.) << " " << (1. + std::pow(2.e-2,1.2e-1) ) << std::endl;
ok &= ret;
ff = new TFormula("ff","x^-1.2e1");
ret = ( ff->Eval(1.5) == std::pow(1.5,-1.2e1) ) ;
if (!ret) std::cout << "Error in test25 - ff(1.5) != pow " << ff->Eval(1.5) << " " << std::pow(1.5,-1.2e1) << std::endl;
ok &= ret;
ff = new TFormula("ff","1.5e2^x");
ret = ( ff->Eval(2) == std::pow(1.5e2,2) );
if (!ret) std::cout << "Error in test25 - ff(2) != pow " << ff->Eval(2) << " " << std::pow(1.5e2,2) << std::endl;
ok &= ret;
ff = new TFormula("ff","1.5e2^x^-1.1e-2");
ret = ( ff->Eval(2.) == std::pow(1.5e2, std::pow(2,-1.1e-2) ) );
if (!ret) std::cout << "Error in test25 - ff(2) != pow^pow " << ff->Eval(2.) << " " << std::pow(1.5e2, std::pow(2,-1.1e-2) ) << std::endl;
ok &= ret;
// test same prelacements
ff = new TFormula("ff","pol10(3)+pol2");
std::vector<double> p = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
ff->SetParameters(p.data() );
double sum = 0; for (auto &a : p) { sum+= a;}
ret = ( ff->Eval(1.) == sum );
if (!ret) std::cout << "Error in test25 - ff(1) != sum " << ff->Eval(1.) << " " << sum << std::endl;
ok &= ret;
return ok;
}
bool test26() {
// test sign function
bool ok = true;
TF1 f("f","x*sign(1.,x+2.)");
ok &= (f.Eval(2) == 2);
ok &= (f.Eval(-1) == -1);
ok &= (f.Eval(-3) == 3);
TF1 f2("f2","x*TMath::Sign(1,x+2)");
ok &= (f2.Eval(2) == 2);
ok &= (f2.Eval(-1) == -1);
ok &= (f2.Eval(-3) == 3);
TF1 f3("f3","TMath::SignBit(x-2)");
ok &= (f3.Eval(1) == 1);
ok &= (f3.Eval(3) == 0);
return ok;
}
bool test27() {
// test ssq function
bool ok = true;
TF1 f1("f1","x+sq(x+2)+sq(x+[0])");
TF1 f2("f2","x+(x+2)^2+(x+[0])^2");
f1.SetParameter(0,3); f2.SetParameter(0,3);
ok &= fpEqual(f1.Eval(2) , f2.Eval(2));
ok &= fpEqual(f1.Eval(-4) , f2.Eval(-4));
// test nested expressions and conflict with sqrt
TF1 f3("f3","sqrt(1.+sq(x))");
ok &= fpEqual(f3.Eval(2) , sqrt(5) );
TF1 f4("f4","sq(1.+std::sqrt(x))");
ok &= fpEqual(f4.Eval(2) , TMath::Sq(1.+sqrt(2)) );
TF1 f5("f5","sqrt(((TMath::Sign(1,[0])*sq([0]/x))+(sq([1])*(x^([3]-1))))+sq([2]))");
auto func = [](double *x, double *p){ return TMath::Sqrt(((TMath::Sign(1,p[0])*TMath::Sq(p[0]/x[0]))+(TMath::Sq(p[1])*(TMath::Power(x[0],(p[3]-1)))))+TMath::Sq(p[2])); };
TF1 f6("f6",func,-10,10,4);
f5.SetParameters(-1,2,3,4); f6.SetParameters(f5.GetParameters());
ok &= fpEqual(f5.Eval(2) , f6.Eval(2) );
return ok;
}
bool test28() {
bool ok = true;
// test composition of two functions
TF1 fsin("fsin", "[0]*sin(x)", 0., 10.);
fsin.SetParNames( "sin");
fsin.SetParameter( 0, 2.1);
TF1 fcos("fcos", "[0]*cos(x)", 0., 10.);
fcos.SetParNames( "cos");
fcos.SetParameter( 0, 1.1);
TF1 fsincos("fsc", "fsin+fcos");
// keep same order in evaluation
TF1 f0("f0",[](double *x, double *p){ return p[1]*sin(x[0]) + p[0]*cos(x[0]);},0.,10.,2);
f0.SetParameters(1.1,2.1);
#ifdef R__B64
bool epsilon = false;
#else
bool epsilon = true;
#endif
ok &= fpEqual(fsincos.Eval(2) , f0.Eval(2), epsilon);
return ok;
}
bool test29() {
// test hexadecimal numbers
bool ok = true;
TF1 f1("f1","x+[0]*0xaf");
f1.SetParameter(0,2);
ok &= (f1.Eval(3) == (3.+2*175.) );
TF1 f2("f2","0x64^2+x");
ok &= (f2.Eval(1) == 10001 );
TF1 f3("f3","x^0x000c+1");
ok &= (f3.Eval(2) == 4097 );
return ok;
}
bool test30() {
// handle -- (++ is in linear expressions)
bool ok = true;
TF1 f1("f1","x--[0]");
f1.SetParameter(0,2);
ok &= (f1.Eval(3) == 5. );
return ok;
}
bool test31() {
// test whitespaces in par name and cloning
bool ok = true;
TF1 f1("f1","x*[0]");
f1.SetParameter(0,2);
f1.SetParName(0,"First Param");
auto f2 = (TF1*) f1.Clone();
ok &= (f1.Eval(3) == f2->Eval(3) );
ok &= (TString(f1.GetParName(0) ) == TString(f2->GetParName(0) ) );
return ok;
}
bool test32() {
// test polynomial are linear and have right number
bool ok = true;
TF1 f1("f1","pol2");
ok &= (f1.GetNumber() == 302);
ok &= (f1.IsLinear() );
TF1 f2("f2","gaus(0)+pol1(3)");
ok &= (f2.GetNumber() == 0);
ok &= (!f2.IsLinear());
return ok;
}
bool test33() {
// test new bigaus pre-defined funcition
bool ok = true;
TF2 f1("f1","bigaus",-10,10,-10,10);
ok &= (f1.GetNumber() == 112);
ok &= (std::string(f1.GetParName(5)) == "Rho");
f1.SetParameters(1,0,1,1,2,0.);
TF2 f2("f2","xygaus",-10,10,-10,10);
f2.SetParameters(1,0,1,1,2);
ok &= TMath::AreEqualAbs( f1.Eval(0), f2.Eval(0)/(f2.Integral(-10,10,-20,20) ), 1.E-4 );
if (!ok) std::cout << "Error in test33 - " << f1.Eval(0) << " " << f2.Eval(0)/f2.Integral(-10,10,-10,10) << std::endl;
return ok;
}
bool test34() {
// test for bug 8105
bool ok = true;
TF1 f1("f1","(1.- gaus)*[3]",-10,10);
f1.SetParameters(1,0,1,3);
ok &= TMath::AreEqualAbs( f1.Eval(1), (1.- TMath::Gaus(1,0,1) )*3., 1.E-10);
return ok;
}
bool test35() {
// test for similar pre-defined functions
bool ok = true;
TF1 f1("f1","cheb1(0)+cheb10(2)",-1,1);
std::vector<double> par(13);
par.assign(13,1.); par[1] = 2; par[2] = 3;
TF1 g1("g1",[](double *x, double *p){ return ROOT::Math::ChebyshevN(1, x[0], p ) + ROOT::Math::ChebyshevN(10,x[0],p+2 ); }, -1, 1, 13);
f1.SetParameters(par.data());
g1.SetParameters(par.data());
ok &= TMath::AreEqualRel( f1.Eval(2), g1.Eval(2), 1.E-6);
if (!ok) std::cout << "Error in test35 - f1 != g1 " << f1.Eval(2) << " " << g1.Eval(2) << std::endl;
TF1 f2("f2","cheb10(0)+cheb1(11)",-1,1);
TF1 g2("g2",[](double *x, double *p){ return ROOT::Math::ChebyshevN(10, x[0], p ) + ROOT::Math::ChebyshevN(1,x[0],p+11 ); }, -1, 1, 13);
f2.SetParameters(par.data());
g2.SetParameters(par.data());
ok &= TMath::AreEqualRel( f2.Eval(2), g2.Eval(2), 1.E-6);
if (!ok) std::cout << "Error in test35 - f2 != g2 " << f2.Eval(2.) << " " << g2.Eval(2.) << std::endl;
return ok;
}
bool test36() {
// test for mixed dim functions
bool ok = true;
TF2 f1("f1","xygaus(0) + gaus(5)");
f1.SetParameters(1,0,1,1,2,2,-1,1);
auto g1 = [](double x, double y){ return TMath::Gaus(x,0,1)*TMath::Gaus(y,1,2)+2.*TMath::Gaus(x,-1,1); };
ok &= TMath::AreEqualAbs( f1.Eval(1,1), g1(1,1), 1.E-10);
TF2 f2("f2","xygaus(0) + gaus[y](5)");
f2.SetParameters(1,0,1,1,2,2,-1,1);
auto g2 = [](double x, double y){ return TMath::Gaus(x,0,1)*TMath::Gaus(y,1,2)+2.*TMath::Gaus(y,-1,1); };
ok &= TMath::AreEqualAbs( f2.Eval(1,1), g2(1,1), 1.E-10);
return ok;
}
bool test37() {
// test for inserting correcting polynomials (bug ROOT-8496)
bool ok = true;
TF1 f1("f1","[0]*pol1(1) + pol2(3)*[6]",0,1);
f1.SetParameters(2,1,2,1,2,3,4);
auto ref = [](double x) { return 2 * (1 + 2*x ) + (1 + 2*x + 3*x*x) * 4 ; };
ok &= TMath::AreEqualAbs( f1.Eval(0.5), ref(0.5), 1.E-10);
return ok;
}
bool test38() {
// test for missing parameters (bug ROOT-8182)
bool ok = true;
TF1 f1("f1","[1]",0,1);
f1.SetParameters(999,2);
ok &= (f1.Eval(0) == 2.);
TF1 f2("f2","[A]+[1]*x",0,1);
f2.SetParameters(999,2,3);
ok &= (f2.Eval(2) == 7.);
return ok;
}
bool test39() {
// test special characters in parameter names (bug ROOT-8303)
// test with operator ^, @ and predefined functions (pol, gaus, etc..)
bool ok = true;
TF1 f1("f1","[s^x]*x+[0]");
f1.SetParameters(1,2);
ok &= (f1.Eval(2) == 2*2+1);
TF1 f2("f2","[0]*x+[s@x]");
f2.SetParameters(2,1);
ok &= (f2.Eval(2) == 2*2+1);
TF1 f3("f2","[0]*x+[pol_par_1]");
f3.SetParameters(2,1);
ok &= (f3.Eval(2) == 2*2+1);
TF1 f4("f2","gaus+[gaus_offset]*x");
f4.SetParameters(2,2,1,3);
ok &= (f4.Eval(2) == 2+3*2);
return ok;
}
bool test40()
{
// test parsing variables/parameters of user-defined functions
TF2 f1("f1", "x - y", 0, 5, 0, 5);
TF2 f2("f2", "f1(y,x)", 0, 5, 0, 5);
bool ok = (f1.Eval(1, 2) == -1);
ok &= (f2.Eval(1, 2) == 1);
TF3 f3("f3", "x + 2*y + 3*z", 0, 5, 0, 5, 0, 5);
TF1 f4("f4", "f3(x,x,x)", 0, 5);
ok &= (f3.Eval(2, 2, 2) == 12);
ok &= (f4.Eval(2) == 12);
TF1 f5("f5", "[0]*x + [1]", 0, 5);
TF1 f6("f6", "f5(x,[1],[0])", 0, 5);
f6.SetParameters(1, 2);
ok &= (f6.Eval(0) == 1);
ok &= (f6.Eval(1) == 3);
// implicit x now
TF1 f7("f7", "f5([1], [0])", 0, 5);
f7.SetParameters(1, 2);
ok &= (f7.Eval(0) == 1);
ok &= (f7.Eval(1) == 3);
// now implicit parameters
TF2 f8("f8", "f5(y)", 0, 5, 0, 5);
f8.SetParameters(1, 2);
ok &= (f8.Eval(0, 0) == 2);
ok &= (f8.Eval(1, 0) == 2);
ok &= (f8.Eval(0, 1) == 3);
ok &= (f8.Eval(1, 1) == 3);
// and test [p0] notation
TF1 f9("f9", "[p0]*x + [p1]", 0, 5);
TF1 f10("f10", "f9(x,[p1],[p0])", 0, 5);
f10.SetParameters(1, 2);
ok &= (f10.Eval(0) == 1);
ok &= (f10.Eval(1) == 3);
// implicit x now
TF1 f11("f11", "f9([p1], [p0])", 0, 5);
f11.SetParameters(1, 2);
ok &= (f11.Eval(0) == 1);
ok &= (f11.Eval(1) == 3);
return ok;
}
bool test41()
{
// Test variable/parameter parsing for parametrized functions
bool ok = true;
// old variable-counting method
TF1 f1("f1", "gaus(0) + gaus(3)", -5, 5);
f1.SetParameters(1, 0, 1, 1, 1, 1);
ok &= fpEqual(f1.Eval(0), 1 + TMath::Exp(-.5), true);
ok &= fpEqual(f1.Eval(1), 1 + TMath::Exp(-.5), true);
// new param-range method
TF1 f2("f2", "gaus([0..2]) + gaus([3..5])", -5, 5);
f2.SetParameters(1, 0, 1, 1, 1, 1);
ok &= fpEqual(f2.Eval(0), 1 + TMath::Exp(-.5), true);
ok &= fpEqual(f2.Eval(1), 1 + TMath::Exp(-.5), true);
TF1 f3("f3", "[0] + gaus([1..3])", -5, 5);
f3.SetParameters(2, 1, 0, 1);
ok &= fpEqual(f3.Eval(0), 3, true);
ok &= fpEqual(f3.Eval(1), 2 + TMath::Exp(-.5), true);
TF2 f4("f4", "gaus(y)", -5, 5, -5, 5);
f4.SetParameters(2, 0, 1);
ok &= fpEqual(f4.Eval(0, 0), 2, true);
ok &= fpEqual(f4.Eval(1, 0), 2, true);
ok &= fpEqual(f4.Eval(0, -1), 2 * TMath::Exp(-.5), true);
ok &= fpEqual(f4.Eval(1, -1), 2 * TMath::Exp(-.5), true);
TF2 f5("f5", "[0] + gaus(y, [1..3])", -5, 5, -5, 5);
f5.SetParameters(0, 2, 0, 1);
ok &= fpEqual(f5.Eval(0, 0), 2, true);
ok &= fpEqual(f5.Eval(1, 0), 2, true);
ok &= fpEqual(f5.Eval(0, -1), 2 * TMath::Exp(-.5), true);
ok &= fpEqual(f5.Eval(1, -1), 2 * TMath::Exp(-.5), true);
return ok;
}
bool test42()
{
// Test variable parsing when using form x[N]
bool ok = true;
TF2 f1("f1", "x[1] + 1", -5, 5, -5, 5);
ok &= (f1.Eval(1, 1) == 2);
ok &= (f1.Eval(0, 1) == 2);
ok &= (f1.Eval(1, 0) == 1);
ok &= (f1.Eval(0, 0) == 1);
TF2 f2("f2", "f1(y,x) + 0*y", -5, 5, -5, 5);
ok &= (f2.Eval(1, 1) == 2);
ok &= (f2.Eval(0, 1) == 1);
ok &= (f2.Eval(1, 0) == 2);
ok &= (f2.Eval(0, 0) == 1);
TF2 f3("f3", "f1(x[1], x[0]) + 0*y", -5, 5, -5, 5);
ok &= (f3.Eval(1, 1) == 2);
ok &= (f3.Eval(0, 1) == 1);
ok &= (f3.Eval(1, 0) == 2);
ok &= (f3.Eval(0, 0) == 1);
return ok;
}
bool test43()
{
// test whether value of parameter name carries through
bool ok = true;
TF1 f1("f1", "[const] + [linear]*x", -5, 5);
f1.SetParameters(1, 2);
TF1 f2("f2", "f1", -5, 5);
ok &= (f2.Eval(1) == 3);
TF1 f3("f3", "f1(x, [const], [linear])", -5, 5);
ok &= (f3.Eval(1) == 3);
TF1 f4("f4", "f1([const], [linear])", -5, 5);
ok &= (f4.Eval(1) == 3);
TF1 f5("f5", "f1(x)", -5, 5);
ok &= (f5.Eval(1) == 3);
TF1 f6("f6", "f1([first], [second])");
// parameters "should" initialize to zero
ok &= (f6.Eval(1) == 0);
return ok;
}
bool test44()
{
// test whether user-defined and parametrized functions can be nested
bool ok = true;
TF1 f1("f1", "x**[0]");
TF1 f2("f2", "x + 1");
TF2 f3("f3", "f1(f2(x), y)");
ok &= (f3.Eval(2, 3) == 27);
TF1 f4("f4", "f2(f2(x))");
ok &= (f4.Eval(5) == 7);
TF1 f5("f5", "gaus(f2(x), 1, 0, 1)");
ok &= fpEqual(f5.Eval(0), TMath::Exp(-.5), true);
TF1 f6("f6", "gaus(gaus(x, 1, 0, 1), 1, 0, 1)");
ok &= fpEqual(f6.Eval(0), TMath::Exp(-.5), true);
return ok;
}
bool test45()
{
// test dealing with whitespace in parameter names
// inlcuding cloning tests (see ROOT-8971)
TF1* func = new TF1("expo","expo");
func->SetParNames("A", "- 1 / T");
func->SetParameters(1,1);
TF1 * func2 = (TF1*) func->Clone("func2");
bool ok = fpEqual( func2->Eval(2), func->Eval(2), true);
return ok;
}
bool test46() {
// test multi-dim formula (like new xyzgaus)
auto func = new TF3("f3","xyzgaus");
func->SetParameters(2,1,2,3,4,5,6);
bool ok = fpEqual( func->Eval(2,4,6), 2.*TMath::Gaus(2,1,2)*TMath::Gaus(4,3,4)*TMath::Gaus(6,5,6) , true);
auto func2 = new TF3("f3","gaus(x,[0],[1],[2])*gaus(y,1,[3],[4])*gaus(z,1,[5],[6])");
double x[] = {2,4,6};
ok &= fpEqual( func->EvalPar(x,nullptr), func2->EvalPar(x, func->GetParameters() ), true );
return ok;
}
bool test47() {
// test mod operator
// one needs to convert always to integer because % works only for int
auto f1 = new TF1("f1","exp(x)");
(void)f1; // f1 is used by modf but the compiler doesn't see that.
auto func = new TF1("modf","int(2*f1(x)) % 3");
bool ok = func->Eval(1) == 2;
ok &= func->Eval(3) == 1;
ok &= func->Eval(1.2) == 0;
return ok;
}
bool test48() {
// test creating two identical functions
// and reading back from a file
// ROOT-9467
// The bug woruld need to exit ROOT and when the file already esists
TString fname = "TFormulaTest48.root";
int prevErr = gErrorIgnoreLevel;
gErrorIgnoreLevel = kFatal;
TFile* f = TFile::Open(fname);
gErrorIgnoreLevel = prevErr;
if (!f) {
TFile * fout = TFile::Open(fname,"NEW");
TF1* f1 = new TF1("f1", "[0] + [1]*x+2.0", 0, 1);
TF1* f2 = new TF1("f2", "[0] + [1]*x+2.0", 0, 1);
f1->SetParameters(1,1);
f2->SetParameters(0,2);
f1->Write();
f2->Write();
fout->Close();
f = TFile::Open(fname);
}
TF1* f1 = dynamic_cast<TF1*>(f->Get("f1"));
TF1* f2 = dynamic_cast<TF1*>(f->Get("f2"));
bool ok = f1 != nullptr && f2 != nullptr;
if (ok) {
ok &= (f1->Eval(1) == 4. && f1->Eval(1) == f2->Eval(1) );
}
return ok;
}
bool test49() {
// test copy consttructor in case of lazy initialization (i.e. when reading from a file)
TFile* f = TFile::Open("TFormulaTest49.root","RECREATE");
if (!f) {
Error("test49","Error creating file for test49");
return false;
}
TF1 f1("f1","x*[0]");
f1.SetParameter(0,2);
f1.Write();
f->Close();
// read the file
f = TFile::Open("TFormulaTest49.root");
if (!f) {
Error("test49","Error reading file for test49");
return false;
}
auto fr = (TF1*) f->Get("f1");
if (!fr) {
Error("test49","Error reading function from file for test49");
return false;
}
// create a copy
TF1 fr2 = *fr;
bool ok = (fr->Eval(2.) == 4.);
ok &= ( fr2.Eval(2.) == fr->Eval(2.) );
// now read using an indpendent process (ROOT session)
// this should cause ROOT-9801
TMacro m;
m.AddLine("bool TFormulaTest49() { TFile * f = TFile::Open(\"TFormulaTest49.root\");"
"TF1 *f1 = (TF1*) f->Get(\"f1\"); TF1 f2 = *f1;"
"bool ok = (f1->Eval(2) == f2.Eval(2.)) && (f2.Eval(2.) == 4.);"
"if (!ok) Error(\"test49\",\"Error in test49 (lazy initialization)\");"
"return ok; }");
m.SaveSource("TFormulaTest49.C");
int ret = gSystem->Exec("root.exe -q -l -i TFormulaTest49.C");
ok |= (ret == 0);
return ok;
}
bool test50() {
// test detailed printing of function
TFormula f1("f1","[A]*sin([B]*x)");
f1.Print("V");
bool ok = f1.IsValid();
TF2 f2("f2","[0]*x+[1]*y");
f2.Print("V");
ok &= f2.GetFormula()->IsValid();
// create using lambda expression, need to pass ndim and npar
TFormula f3("f3","[](double *x, double *p){ return p[0]*x[0] + p[1]; } ",1,2);
f3.Print("V");
ok &= f3.IsValid();
// create again using lambda from TF1, need to pass xmin(0.),xmax(1.), npar (1)
TF1 f4("f3","[](double *x, double *p){ return p[0]*x[0]; } ",0.,1.,1);
f4.Print("V");
ok &= f3.IsValid();
return ok;
}
bool test51() {
//switch off error messages to have test passing
int prevLevel = gErrorIgnoreLevel;
gErrorIgnoreLevel= kFatal;
TFormula f("fMissingParenthesis", "exp(x");
bool ok = !f.IsValid();
TFormula f2("fEmpty", "");
ok &= !f2.IsValid();
TFormula f3("fNonsense", "skmg#$#@!1");
ok &= !f3.IsValid();
gErrorIgnoreLevel = prevLevel;
return ok;
}
bool test52() {
// test for bug 10815
// mixing user previous defined functions (available in gROOT)
// and pre-defined functions
bool ok = true;
TF1 f1("f1gaus","[0]*gaus(1)",-10,10);
TF1 f2("f2","[0]*f1gaus",-10,10);
f1.SetParameters(2,3,1,2);
f2.SetParameters(3,2,3,1,2);
ok &= TMath::AreEqualAbs( f1.Eval(1), 2.*3.*TMath::Gaus(1,1,2), 1.E-10);
if (!ok) Error("test52","Error testing f1");
bool ret = TMath::AreEqualAbs( f2.Eval(1), 3.*2.*3.*TMath::Gaus(1,1,2), 1.E-10);
if (!ret) Error("test52","Error testing f2");
ok &= ret;
TF1 f3("f3","f1gaus*gaus(4)",-10,10);
f3.SetParameters(2,3,1,2,3,2,3);
ret = TMath::AreEqualAbs( f3.Eval(1), 2.*3.*TMath::Gaus(1,1,2) * 3. * TMath::Gaus(1,2,3), 1.E-10);
if (!ret) Error("test52","Error testing f3");
ok &= ret;
// check also after
TF1 f4("gaus2a","[0]*gaus(1)",-10,10);
TF1 f5("f2","[0]*gaus2a",-10,10);
f4.SetParameters(2,3,1,2);
f5.SetParameters(3,2,3,1,2);
ret = TMath::AreEqualAbs( f5.Eval(1), 3.*f4.Eval(1),1.E-10);
if (!ret) Error("test52","Error testing f4 & f5");
return ok;
}
bool test53()
{
// Test if a formula with linear terms in each parameter is correctly expanded,
// even if some earlier terms are substrings of later terms.
bool ok = true;
TF1 f1("f1", "1.0 ++ x ++ x*x ++ x*x*x", -1.0, 1.0);
ok &= f1.GetNpar() == 4;
return ok;
}
///////////////////////////////////////////////////////////////////////////////////////
void PrintError(int itest) {
Error("TFormula test","test%d FAILED ",itest);
failedTests.push_back(itest);
}
void IncrTest(int & itest) {
if (itest > 0) std::cout << ".\n";
itest++;
std::cout << "Test " << itest << " : ";
}
int runTests(bool debug = false) {
verbose = debug;
int itest = 0;
IncrTest(itest); if (!test1() ) { PrintError(itest); }
IncrTest(itest); if (!test2() ) { PrintError(itest); }
IncrTest(itest); if (!test3() ) { PrintError(itest); }
IncrTest(itest); if (!test4() ) { PrintError(itest); }
IncrTest(itest); if (!test5() ) { PrintError(itest); }
IncrTest(itest); if (!test6() ) { PrintError(itest); }
IncrTest(itest); if (!test7() ) { PrintError(itest); }
IncrTest(itest); if (!test8() ) { PrintError(itest); }
IncrTest(itest); if (!test9() ) { PrintError(itest); }
IncrTest(itest); if (!test10() ) { PrintError(itest); }
IncrTest(itest); if (!test11() ) { PrintError(itest); }
IncrTest(itest); if (!test12() ) { PrintError(itest); }
IncrTest(itest); if (!test13() ) { PrintError(itest); }
IncrTest(itest); if (!test14() ) { PrintError(itest); }
IncrTest(itest); if (!test15() ) { PrintError(itest); }
IncrTest(itest); if (!test16() ) { PrintError(itest); }
IncrTest(itest); if (!test17() ) { PrintError(itest); }
IncrTest(itest); if (!test18() ) { PrintError(itest); }
IncrTest(itest); if (!test19() ) { PrintError(itest); }
IncrTest(itest); if (!test20() ) { PrintError(itest); }
IncrTest(itest); if (!test21() ) { PrintError(itest); }
IncrTest(itest); if (!test22() ) { PrintError(itest); }
IncrTest(itest); if (!test23() ) { PrintError(itest); }
IncrTest(itest); if (!test24() ) { PrintError(itest); }
IncrTest(itest); if (!test25() ) { PrintError(itest); }
IncrTest(itest); if (!test26() ) { PrintError(itest); }
IncrTest(itest); if (!test27() ) { PrintError(itest); }
IncrTest(itest); if (!test28() ) { PrintError(itest); }
IncrTest(itest); if (!test29() ) { PrintError(itest); }
IncrTest(itest); if (!test30() ) { PrintError(itest); }
IncrTest(itest); if (!test31() ) { PrintError(itest); }
IncrTest(itest); if (!test32() ) { PrintError(itest); }
IncrTest(itest); if (!test33() ) { PrintError(itest); }
IncrTest(itest); if (!test34() ) { PrintError(itest); }
IncrTest(itest); if (!test35() ) { PrintError(itest); }
IncrTest(itest); if (!test36() ) { PrintError(itest); }
IncrTest(itest); if (!test37() ) { PrintError(itest); }
IncrTest(itest); if (!test38() ) { PrintError(itest); }
IncrTest(itest); if (!test39() ) { PrintError(itest); }
IncrTest(itest); if (!test40() ) { PrintError(itest); }
IncrTest(itest); if (!test41() ) { PrintError(itest); }
IncrTest(itest); if (!test42() ) { PrintError(itest); }
IncrTest(itest); if (!test43() ) { PrintError(itest); }
IncrTest(itest); if (!test44() ) { PrintError(itest); }
IncrTest(itest); if (!test45() ) { PrintError(itest); }
IncrTest(itest); if (!test46() ) { PrintError(itest); }
IncrTest(itest); if (!test47() ) { PrintError(itest); }
IncrTest(itest); if (!test48() ) { PrintError(itest); }
IncrTest(itest); if (!test49() ) { PrintError(itest); }
IncrTest(itest); if (!test50() ) { PrintError(itest); }
IncrTest(itest); if (!test51() ) { PrintError(itest); }
IncrTest(itest); if (!test52() ) { PrintError(itest); }
IncrTest(itest); if (!test53() ) { PrintError(itest); }
std::cout << ".\n";
if (failedTests.size() == 0)
std::cout << "All TFormula Parsing tests PASSED !" << std::endl;
else {
Error("TFORMULA Tests","%d tests failed ",int(failedTests.size()) );
std::cout << "failed tests are : ";
for (auto & ittest : failedTests) {
std::cout << ittest << " ";
}
std::cout << std::endl;
}
return failedTests.size();
}
};