class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../tadpole2L_rank2/tadpole2L_rank2_pylink.so') # set global options self.real_parameters = [1., 1., 1.] self.complex_parameters = [] self.maxeval = 10**6 self.epsrel = 1e-8 self.epsabs = 1e-10 self.target_result_without_prefactor = \ { -1: 10.0, 0: - 4.0, 1: -34.5127841 } self.target_prefactor = \ { -1: -0.25, 0: -0.461392167549234, 1: -1.87323249797567 } def check_result(self, computed_series, target_series, epsrel, epsabs, order_min, order_max): # convert result to sympy expressions if '+/-' in computed_series: computed_series = sp.sympify( computed_series.replace(',', '+I*').replace('+/-', '*value+error*')) else: computed_series = ( sp.sympify(computed_series.replace(',', '+I*')) * sp.sympify('value')).expand() for order in range(order_min, order_max + 1): value = complex(computed_series.coeff('eps', order).coeff('value')) error = complex(computed_series.coeff('eps', order).coeff('error')) # check that the uncertainties are reasonable self.assertLessEqual(error.real, abs(2 * epsrel * target_series[order].real)) if target_series[order].imag != 0.0: self.assertLessEqual( error.imag, abs(2 * epsrel * target_series[order].imag)) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real)) if target_series[order].imag == 0.0: self.assertLessEqual(error.imag, epsabs) else: self.assertLessEqual(error.imag, abs(epsrel * value.imag)) # check integral value self.assertAlmostEqual(value.real, target_series[order].real, delta=3. * epsrel * abs(target_series[order].real)) if target_series[order].imag == 0.0: self.assertAlmostEqual(value.imag, target_series[order].imag, delta=3. * epsabs) else: self.assertAlmostEqual(value.imag, target_series[order].imag, delta=3. * epsrel * abs(target_series[order].imag)) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_without_prefactor, self.target_result_without_prefactor, self.epsrel, self.epsabs, order_min=-1, order_max=1) # check prefactor self.check_result(str_prefactor, self.target_prefactor, self.epsrel, self.epsabs, order_min=-1, order_max=1) def test_Cuhre_CQuad(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True) self.lib.use_CQuad(epsrel=self.epsrel, epsabs=self.epsabs) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_without_prefactor, self.target_result_without_prefactor, self.epsrel, self.epsabs, order_min=-1, order_max=1) # check prefactor self.check_result(str_prefactor, self.target_prefactor, self.epsrel, self.epsabs, order_min=-1, order_max=1)
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../regulator_in_powerlist/regulator_in_powerlist_pylink.so') # set global options self.maxeval = 10**7 self.epsrel = 1e-3 self.epsabs = 1e-4 self.lib.use_Cuhre(self.epsrel, self.epsabs, flags=2, real_complex_together=True, maxeval=self.maxeval) self.lib.use_CQuad(self.epsrel, self.epsabs, verbose=True) # expected result self.target_result_without_prefactor_without_kinematics = sp.sympify( ''' + 7/3 * eps ** -4 + 0 * eps ** -3 - 30.7054359 * eps ** -2 ''') self.target_prefactor = sp.sympify(''' (-s)**(-4*eps - 1)*exp(-I*pi*(2*eps + 3))*gamma(4*eps + 1)/gamma(eps)**2 ''').series(sp.symbols('eps'), n=5) self.order_min = -2 self.order_max = 0 def check_result(self, s): # compute integral str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( [s]) # convert computed result to sympy expressions computed_series = sp.sympify( str_integral_with_prefactor.replace(',', '+I*').replace( '+/-', '*value+error*')) # get target result (with nonstandard prescription of the negative log) log_minus_s = sp.log(-s) if s < 0 else sp.log(s) - sp.I * sp.pi target_result_with_prefactor = \ ( self.target_result_without_prefactor_without_kinematics * \ self.target_prefactor ).expand().replace(sp.sympify('log(-s)'),log_minus_s).subs(sp.sympify('s'),s) # print results print("obtained result without prefactor:\n", str_integral_without_prefactor, '\n') print("obtained result:\n", str_integral_with_prefactor, '\n') print("target result:\n", target_result_with_prefactor.evalf().expand(), '\n') print("----------------\n") for order in range(self.order_min, self.order_max + 1): print('checking order "eps^%i"' % order) computed_value = complex( computed_series.coeff('eps', order).coeff('value')) computed_error = complex( computed_series.coeff('eps', order).coeff('error')) target_value = complex( target_result_with_prefactor.coeff('eps', order)) # check values (`2*epsrel` because the orders are mixed by the prefactor.) if target_value.real == 0.0: self.assertLessEqual(computed_error.real, self.epsabs) self.assertLessEqual(computed_value.real, 2. * computed_error.real) else: self.assertAlmostEqual(computed_value.real, target_value.real, delta=abs(3 * self.epsrel * target_value.real)) if target_value.imag == 0.0: self.assertLessEqual(computed_error.imag, self.epsabs) self.assertLessEqual(computed_value.imag, 2. * computed_error.imag) else: self.assertAlmostEqual(computed_value.imag, target_value.imag, delta=abs(3 * self.epsrel * target_value.imag)) print("----------------\n") def test_Euclidean_point(self): # check integral self.check_result(-2.0) def test_physical_point(self): # check integral self.check_result(+2.0)
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../one_integration_variable/one_integration_variable_pylink.so') self.target_result = {-1: 0.0, 0: -0.5, 1: -0.25} self.epsrel = 1e-11 self.epsabs = 1e-10 self.maxeval = 10**5 def check_result(self, computed_series, epsrel, epsabs): # convert result to sympy expressions integral_with_prefactor = sp.sympify( computed_series.replace(',', '+I*').replace('+/-', '*value+error*')) for order in range(-1, 2): value = complex( integral_with_prefactor.coeff('eps', order).coeff('value')) error = complex( integral_with_prefactor.coeff('eps', order).coeff('error')) # check that the desired uncertainties are reached self.assertLessEqual(error.real, epsabs) self.assertLessEqual(error.imag, epsabs) # check integral value self.assertAlmostEqual(value.real, self.target_result[order].real, delta=3. * epsabs) self.assertAlmostEqual(value.imag, self.target_result[order].imag, delta=3. * epsabs) def test_Vegas(self): # choose integrator # can only reach ~2e-9 accuracy with Vegas self.lib.use_Vegas( flags=0, epsrel=self.epsrel, epsabs=2e-9, maxeval=self.maxeval) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, 2e-9) def test_Suave(self): # choose integrator self.lib.use_Suave( flags=0, epsrel=self.epsrel, epsabs=self.epsabs, maxeval=5000) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_Divonne(self): # choose integrator self.lib.use_Divonne( flags=0, epsrel=self.epsrel, epsabs=self.epsabs, border=1e-8, maxeval=self.maxeval) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre( flags=0, epsrel=self.epsrel, epsabs=self.epsabs, maxeval=self.maxeval) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_CQuad(self): # choose integrator self.lib.use_CQuad(verbose=False, epsrel=self.epsrel, epsabs=self.epsabs) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_default_transform(self): # choose integrator self.lib.use_Qmc(verbosity=0, epsrel=self.epsrel, epsabs=self.epsabs, seed=3212, transform='korobov3', fitfunction='polysingular') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_no_transform(self): # choose integrator self.lib.use_Qmc(verbosity=0, epsrel=self.epsrel, epsabs=self.epsabs, seed=3212, transform='none', fitfunction='none') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_Korobov2x1_transform(self): # choose integrator self.lib.use_Qmc(verbosity=0, epsrel=self.epsrel, epsabs=self.epsabs, seed=3212, transform='Korobov2x1') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( ) # check self.check_result(str_integral_with_prefactor, self.epsrel, self.epsabs)
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary('../mixed_packages/mixed_packages_pylink.so') # set global options self.real_parameters = [10., 2.] self.complex_parameters = [] self.maxeval = 10**7 self.epsrel = 1e-4 self.epsabs = 1e-7 # s/msq * bub(s,msq,msq) + msq/s* Integrate[1/(s z1 + msq z2 z3), {z1, 0, 1}, {z2, 0, 1}, {z3, 0, 1}] self.target_result_with_prefactor = \ { -1: 5.0 + 0.0j, 0: 10.63956085778167 + 7.024814731040726j, } self.order_min = -1 self.order_max = 0 def check_result(self, computed_series, target_series, epsrel, epsabs): # convert result to sympy expressions computed_series = sp.sympify( computed_series.replace(',','+I*').replace('+/-','*value+error*') ) for order in range(self.order_min, self.order_max+1): value = complex( computed_series.coeff('eps',order).coeff('value') ) error = complex( computed_series.coeff('eps',order).coeff('error') ) # check that the uncertainties are reasonable self.assertLessEqual(error.real, abs(2*epsrel * target_series[order].real)) if target_series[order].imag != 0.0: self.assertLessEqual(error.imag, abs(2*epsrel * target_series[order].imag)) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real) ) if target_series[order].imag == 0.0: self.assertLessEqual(error.imag, epsabs) else: self.assertLessEqual(error.imag, abs(epsrel * value.imag) ) # check integral value self.assertAlmostEqual( value.real, target_series[order].real, delta=3.*epsrel*abs(target_series[order].real) ) if target_series[order].imag == 0.0: self.assertAlmostEqual( value.imag, target_series[order].imag, delta=3.*epsabs ) else: self.assertAlmostEqual( value.imag, target_series[order].imag, delta=3.*epsrel*abs(target_series[order].imag) ) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True, flags=0) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib(self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs) def test_Cuhre_CQuad(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True, flags=0) self.lib.use_CQuad(epsrel=self.epsrel, epsabs=self.epsabs, verbose=False) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib(self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_default_integral_transform(self): # choose integrator self.lib.use_Qmc(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, verbosity=0, seed=143, transform='korobov3') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib(self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs)
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../bubble1L_dot_rank4/bubble1L_dot_rank4_pylink.so') # set global options self.real_parameters = [1.275, 1.275] self.complex_parameters = [30.886875, 30.886875, 123.5475] self.maxeval = 10**6 self.epsrel = 1e-4 self.epsabs = 1e-7 self.target_result_with_prefactor = \ { -1: 1.0 + 0.0j, 0: -1.2708 + 2.4179j } self.order_min = -1 self.order_max = 0 def check_result(self, computed_series, target_series, epsrel, epsabs): # convert result to sympy expressions computed_series = sp.sympify( computed_series.replace(',', '+I*').replace('+/-', '*value+error*')) for order in range(self.order_min, self.order_max + 1): value = complex(computed_series.coeff('eps', order).coeff('value')) error = complex(computed_series.coeff('eps', order).coeff('error')) # check that the uncertainties are reasonable self.assertLessEqual(error.real, abs(2 * epsrel * target_series[order].real)) if target_series[order].imag != 0.0: self.assertLessEqual( error.imag, abs(2 * epsrel * target_series[order].imag)) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real)) if target_series[order].imag == 0.0: self.assertLessEqual(error.imag, epsabs) else: self.assertLessEqual(error.imag, abs(epsrel * value.imag)) # check integral value self.assertAlmostEqual(value.real, target_series[order].real, delta=3. * epsrel * abs(target_series[order].real)) if target_series[order].imag == 0.0: self.assertAlmostEqual(value.imag, target_series[order].imag, delta=3. * epsabs) else: self.assertAlmostEqual(value.imag, target_series[order].imag, delta=3. * epsrel * abs(target_series[order].imag)) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True, flags=0) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs) def test_Cuhre_CQuad(self): # choose integrator self.lib.use_Cuhre(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, real_complex_together=True, flags=0) self.lib.use_CQuad(epsrel=self.epsrel, epsabs=self.epsabs, verbose=False) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_default_integral_transform(self): # choose integrator self.lib.use_Qmc(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, verbosity=0, seed=143, transform='korobov3') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs) def test_Qmc_baker_transform(self): # choose integrator self.lib.use_Qmc(epsrel=self.epsrel, maxeval=self.maxeval, epsabs=self.epsabs, verbosity=0, seed=143, transform='baker', evaluateminn=0, fitfunction='polysingular') # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters, self.complex_parameters) # check integral self.check_result(str_integral_with_prefactor, self.target_result_with_prefactor, self.epsrel, self.epsabs)