class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary('../difference/difference_pylink.so') self.target_result = { 0: 1.64493406684822643647241516664602518923 + 3.1415926535897932384626433832795028842j, 1: 2.08781123053685858754509217178101012328 - 6.2831853071795864769252867665590057684j, 2: -5.94029019737039970544633397517750766917 + 4.2570651807194096861418776386549427857j } self.epsrel = 1e-2 def check_result(self, computed_series, epsrel): # convert result to sympy expressions integral_with_prefactor = sp.sympify( computed_series.replace(',','+I*').replace('+/-','*value+error*') ) for order in range(3): value = complex( integral_with_prefactor.coeff('eps',order).coeff('value') ) error = complex( integral_with_prefactor.coeff('eps',order).coeff('error') ) # check that the uncertainties are reasonable self.assertLessEqual(error.real, abs(2*epsrel * self.target_result[order].real)) self.assertLessEqual(error.imag, abs(2*epsrel * self.target_result[order].imag)) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real) ) self.assertLessEqual(error.imag, abs(epsrel * value.imag) ) # check integral value self.assertAlmostEqual( value.real, self.target_result[order].real, delta=3.*epsrel*abs(self.target_result[order].real) ) self.assertAlmostEqual( value.imag, self.target_result[order].imag, delta=3.*epsrel*abs(self.target_result[order].imag) ) def test_Vegas(self): # choose integrator self.lib.use_Vegas(flags=2, epsrel=self.epsrel) # ``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) def test_Suave(self): # choose integrator self.lib.use_Suave(flags=2, epsrel=self.epsrel) # ``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) def test_Divonne(self): # choose integrator self.lib.use_Divonne(flags=2, epsrel=self.epsrel, border=1e-8) # ``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) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre(flags=2, epsrel=self.epsrel) # ``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)
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)
#!/usr/bin/env python3 from pySecDec.integral_interface import IntegralLibrary import sympy as sp if __name__ == "__main__": # load c++ library integral = IntegralLibrary('A92/A92_pylink.so') # choose integrator integral.use_Divonne(flags=2,epsrel=1e-3,epsabs=1e-10,maxeval=10000000,seed=27, border=1e-8) #integral.use_Vegas(flags=2,epsrel=1e-3,epsabs=0,nstart=500,nincrease=10000,maxeval=100000000,seed=27,real_complex_together=True) #integral.use_Vegas(flags=2,epsrel=1e-5,epsabs=1e-30000,nstart=100000,nincrease=30000,maxeval=10000000) #integral.use_Vegas(flags=2,maxeval= 1000000, epsrel=1.e-3, epsabs=0,seed=27) # fast evaluation # ``flags=2``: verbose --> see Cuba manual #integral.use_Cuhre(flags=2,epsrel=1e-2,epsabs=1e-10,maxeval=100000000,real_complex_together=True) #integral.use_CQuad(verbose=True,epsrel=1e-3,epsabs=0) # integrate #str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = integral(number_of_presamples=20000,deformation_parameters_maximum=1e-1,deformation_parameters_minimum=1e-10,together=True) str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = integral() # convert complex numbers from c++ to sympy notation str_integral_with_prefactor = str_integral_with_prefactor.replace(',','+I*') str_prefactor = str_prefactor.replace(',','+I*') str_integral_without_prefactor = str_integral_without_prefactor.replace(',','+I*') # convert result to sympy expressions integral_with_prefactor = sp.sympify(str_integral_with_prefactor.replace('+/-','*value+error*')) integral_with_prefactor_err = sp.sympify(str_integral_with_prefactor.replace('+/-','*value+error*'))
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../userdefined_cpp/userdefined_cpp_pylink.so') # full analytic result for func(y)=1: # (4^-eps (-2 + 2^eps))/((-1 + eps) eps^2) # = 1/eps^2 + (1 - Log[2] - Log[4])/eps + 1/2 (2 - 2 Log[2] - Log[2]^2 - 2 Log[4] + 2 Log[2] Log[4] + Log[4]^2) + O[eps] # = 1.0000000000000000000/eps^2 - 1.0794415416798359283/eps + 0.60214400703386905808 + O[eps] self.target_result = { -2: 1.0, -1: -1.0794415416798359283, 0: 0.60214400703386905808 } self.epsrel = 1e-4 self.maxeval = 10**8 self.epsabs_tol = 1e-15 def check_result(self, computed_series, epsrel): # convert result to sympy expressions integral_with_prefactor = sp.sympify( computed_series.replace(',', '+I*').replace('+/-', '*value+error*')) for order in range(-2, 0): value = complex( integral_with_prefactor.coeff('eps', order).coeff('value')) error = complex( integral_with_prefactor.coeff('eps', order).coeff('error')) # check that the uncertainties are reasonable self.assertLessEqual( error.real, abs(2 * epsrel * self.target_result[order].real) + self.epsabs_tol) self.assertLessEqual( error.imag, abs(2 * epsrel * self.target_result[order].imag) + self.epsabs_tol) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real) + self.epsabs_tol) self.assertLessEqual(error.imag, abs(epsrel * value.imag) + self.epsabs_tol) # check integral value self.assertAlmostEqual( value.real, self.target_result[order].real, delta=3. * epsrel * abs(self.target_result[order].real) + self.epsabs_tol) self.assertAlmostEqual( value.imag, self.target_result[order].imag, delta=3. * epsrel * abs(self.target_result[order].imag) + self.epsabs_tol) def test_Vegas(self): # choose integrator self.lib.use_Vegas( flags=2, epsrel=self.epsrel, 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) def test_Suave(self): # choose integrator self.lib.use_Suave( flags=2, epsrel=self.epsrel, maxeval=self.maxeval, nnew=10**5) # ``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) def test_Divonne(self): # choose integrator self.lib.use_Divonne( flags=2, epsrel=self.epsrel, border=1e-12, 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) def test_Cuhre(self): # choose integrator self.lib.use_Cuhre( flags=2, epsrel=self.epsrel, 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)
#!/usr/bin/env python3 from pySecDec.integral_interface import IntegralLibrary import sympy as sp if __name__ == "__main__": # load c++ library triangle2L_split = IntegralLibrary( 'triangle2L_split/triangle2L_split_pylink.so') # choose integrator triangle2L_split.use_Divonne(epsrel=1e-5, epsabs=1e-5, maxeval=10**7, border=1e-8) # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = triangle2L_split( together=False, verbose=True) # convert complex numbers from c++ to sympy notation str_integral_with_prefactor = str_integral_with_prefactor.replace( ',', '+I*') str_prefactor = str_prefactor.replace(',', '+I*') str_integral_without_prefactor = str_integral_without_prefactor.replace( ',', '+I*') # convert result to sympy expressions integral_with_prefactor = sp.sympify( str_integral_with_prefactor.replace('+/-', '*value+error*'))
class CheckLib(unittest.TestCase): def setUp(self): # load c++ library self.lib = IntegralLibrary( '../userdefined_cpp/userdefined_cpp_pylink.so') self.target_result = {-2: 0.095206, -1: -2.561, 0: 21.120, 1: -78.7} self.real_parameters = [0.77] self.epsrel = 1e-3 self.maxeval = 10**8 self.epsabs_tol = 1e-15 def check_result(self, computed_series, epsrel): # convert result to sympy expressions integral_with_prefactor = sp.sympify( computed_series.replace(',', '+I*').replace('+/-', '*value+error*')) for order in range(-2, 2): value = complex( integral_with_prefactor.coeff('eps', order).coeff('value')) error = complex( integral_with_prefactor.coeff('eps', order).coeff('error')) # check that the uncertainties are reasonable self.assertLessEqual( error.real, abs(2 * epsrel * self.target_result[order].real) + self.epsabs_tol) self.assertLessEqual( error.imag, abs(2 * epsrel * self.target_result[order].imag) + self.epsabs_tol) # check that the desired uncertainties are reached self.assertLessEqual(error.real, abs(epsrel * value.real) + self.epsabs_tol) self.assertLessEqual(error.imag, abs(epsrel * value.imag) + self.epsabs_tol) # check integral value self.assertAlmostEqual( value.real, self.target_result[order].real, delta=3. * epsrel * abs(self.target_result[order].real) + self.epsabs_tol) self.assertAlmostEqual( value.imag, self.target_result[order].imag, delta=3. * epsrel * abs(self.target_result[order].imag) + self.epsabs_tol) def test_Vegas(self): # choose integrator self.lib.use_Vegas( flags=2, epsrel=self.epsrel, maxeval=self.maxeval) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters) # check self.check_result(str_integral_with_prefactor, self.epsrel) def test_Suave(self): # choose integrator self.lib.use_Suave( flags=2, epsrel=self.epsrel, maxeval=self.maxeval) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters) # check self.check_result(str_integral_with_prefactor, self.epsrel) def test_Divonne(self): # choose integrator self.lib.use_Divonne( flags=2, epsrel=self.epsrel, 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( self.real_parameters) # check self.check_result(str_integral_with_prefactor, self.epsrel) def test_Cuhre(self): # choose integrator # Note: Need `mineval` because Cuhre underestimates the error self.lib.use_Cuhre(flags=2, epsrel=self.epsrel, maxeval=self.maxeval, mineval=6 * 10**4) # ``flags=2``: verbose --> see Cuba manual # integrate str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = self.lib( self.real_parameters) # check self.check_result(str_integral_with_prefactor, self.epsrel)