class CheckLib(unittest.TestCase):
def setUp(self):
# load c++ library
self.lib = IntegralLibrary(
'../bubble2L_factorizing/bubble2L_factorizing_pylink.so')
# set global options
self.maxeval = 10**6
self.epsrel = 1e-7
self.epsabs = 1e-15
self.target_result_with_prefactor = \
{
-2: 1.0/36.0 + 0.0j
}
self.target_prefactor = \
{
0: 1.0 + 0.0j
}
def check_integral(self, computed_series, target_series, epsrel, epsabs,
order_min, order_max):
# convert result to sympy expressions
computed_series = sp.sympify(
computed_series.replace(',',
'+I*').replace('+/-', '*value+error*'))
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 check_prefactor(self, computed_series, target_series, order_min,
order_max):
# convert result to sympy expressions
computed_series = sp.sympify(computed_series.replace(',', '+I*'))
for order in range(order_min, order_max + 1):
value = complex(computed_series.coeff('eps', order))
# check value
self.assertAlmostEqual(value.real, target_series[order].real)
self.assertAlmostEqual(value.imag, target_series[order].imag)
def check_Cuhre(self, es12):
# 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(
[es12])
# check integral
self.check_integral(str_integral_with_prefactor,
self.target_result_with_prefactor,
self.epsrel,
self.epsabs,
order_min=-2,
order_max=-2)
# check prefactor
self.check_prefactor(str_prefactor,
self.target_prefactor,
order_min=0,
order_max=0)
def test_Cuhre_Euclidean(self):
self.check_Cuhre(-1.)
def test_Cuhre_physical(self):
self.check_Cuhre(1.)
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(
'../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('../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(
'../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('../box1L_rank4/box1L_rank4_pylink.so')
self.real_parameters = [16.0, -75.0, 1.0]
self.maxeval = 10**8
self.epsrel = 1e-10
self.epsabs = 1e-13
self.target_result_without_prefactor = \
{
-1: 97.52083333333 + 0.0j,
0: -181.22792152123 - 11.903058327787j
}
self.target_prefactor = \
{
0: 1.0
}
self.target_result_with_prefactor = \
{
-1: 97.52083333333 + 0.0j,
0: -181.22792152123 - 11.903058327787j
}
def check_result(self, computed_series, target_series, epsrel, epsabs,
order_min, order_max):
# convert result to sympy expressions
computed_series = sp.sympify(
computed_series.replace(',',
'+I*').replace('+/-', '*value+error*'))
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)
# check integral
#self.check_result(str_integral_without_prefactor, self.target_result_without_prefactor, self.epsrel, self.epsabs, order_min=0, order_max=1)
self.check_result(str_integral_with_prefactor,
self.target_result_with_prefactor,
self.epsrel,
self.epsabs,
order_min=-1,
order_max=0)
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)
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)
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)
