class CheckLib(unittest.TestCase):
def setUp(self):
# load c++ library
self.lib = IntegralLibrary('../bubble1L_ebr/bubble1L_ebr_pylink.so')
# set global options
self.real_parameters = [4., 0.002, 1.]
self.complex_parameters = []
self.maxeval = 10**6
self.epsrel = 1e-4
self.epsabs = 1e-7
self.target_result_with_prefactor = \
{
-2: 0 + 0j,
-1: 1.0 + 0.0j,
0: 4.509087643808781e-02 + 3.138451060936178e+00j # obtained from high precision run of pysecdec
}
self.order_min = -2
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, max( abs(epsrel * value), 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=max( 3.*epsrel*abs(target_series[order]), 3.*epsabs) )
else:
self.assertAlmostEqual( value.imag, target_series[order].imag, delta=3.*epsrel*abs(target_series[order].imag) )
def test_Qmc(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 CheckQmcErrorMessages(unittest.TestCase):
def setUp(self):
# load c++ library
self.lib = IntegralLibrary(
'../one_integration_variable/one_integration_variable_pylink.so')
def test_setting_errormode(self):
self.assertRaisesRegex(ValueError,
'Unknown `errormode` "foo"',
self.lib.use_Qmc,
transform='korobov3',
errormode='foo')
# test known errormodes
self.lib.use_Qmc(errormode='default', transform='korobov3')
self.lib.use_Qmc(errormode='all', transform='korobov3')
self.lib.use_Qmc(errormode='largest', transform='korobov3')
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
import os
if __name__ == "__main__":
# load c++ library
integral = IntegralLibrary('bubble/bubble_pylink.so')
# choose integrator
integral.use_Qmc(verbosity=2,
minn=10**5,
maxeval=0,
minm=10,
transform='korobov3')
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = integral(
real_parameters=[-0.01],
number_of_presamples=10000,
deformation_parameters_maximum=0.01,
deformation_parameters_minimum=0.00000001)
# 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*')
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
if __name__ == "__main__":
# load c++ library
box2L = IntegralLibrary('Nbox2L_split_b/Nbox2L_split_b_pylink.so')
# choose integrator
box2L.use_Qmc(verbosity=0,
minn=10**9,
maxeval=1,
transform='korobov6',
fitfunction='polysingular')
# integrator settings used to run the timings
#box2L.use_Qmc(verbosity=2,minn=10**7,maxeval=1,transform='korobov6',fitfunction='polysingular')
#box2L.use_Qmc(verbosity=2,minn=10**6,maxeval=1,transform='korobov6',fitfunction='polysingular',devices=[-1])
#box2L.use_Vegas(flags=2,maxeval=10**7,epsrel=1e-100,epsabs=1e-100)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = box2L(
real_parameters=[-1.0, -0.8, 0.1], verbose=True)
# print results
print('Numerical Result')
print('integral without prefactor', str_integral_without_prefactor)
print('prefactor', str_prefactor)
print('integral with prefactor', str_integral_with_prefactor)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
from math import pi
import sympy as sp
if __name__ == "__main__":
# load c++ library
two_regulators = IntegralLibrary('two_regulators/two_regulators_pylink.so')
# choose integrator
#two_regulators.use_Vegas()
two_regulators.use_Qmc(transform='korobov3x1')
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = two_regulators(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*'))
integral_with_prefactor_err = sp.sympify(str_integral_with_prefactor.replace('+/-','*value+error*'))
prefactor = sp.sympify(str_prefactor)
integral_without_prefactor = sp.sympify(str_integral_without_prefactor.replace('+/-','*value+error*'))
integral_without_prefactor_err = sp.sympify(str_integral_without_prefactor.replace('+/-','*value+error*'))
# numerical result
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
name = "formfactor1L_massive_ebr"
intlib = IntegralLibrary(f"{name}/{name}_pylink.so")
intlib.use_Qmc(transform="korobov3", verbosity=1)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = intlib(
real_parameters=[100, 0.01])
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(
',', '+I*')
# convert result to sympy expressions
integral_result = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
integral_result_err = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
# examples how to access individual orders
print('Numerical Result')
for power in [-2, -1, 0]:
valreal, valimg = integral_result.coeff(
'eps', power).coeff('value').as_real_imag()
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
# load c++ library
name = "box2L_small_loop_massive_ebr"
intlib = IntegralLibrary("{0}/{0}_pylink.so".format(name))
intlib.use_Qmc(transform="korobov3", fitfunction="polysingular")
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = intlib(
real_parameters=[4.0, -2.82842712475, -2.82842712475, 0.1])
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(',', '+I*')
# convert result to sympy expressions
integral_result = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
integral_result_err = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
# examples how to access individual orders
print('Numerical Result')
for power in [0]:
valreal, valimg = integral_result.coeff(
'eps', power).coeff('value').as_real_imag()
errreal, errimg = integral_result.coeff(
'eps', power).coeff('error').as_real_imag()
print("eps^{:<2} {: .5f}{:+.5f}*I +/- {: .5f}{:+.5f}*I".format(
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
if __name__ == "__main__":
# load c++ library
banana_3mass = IntegralLibrary('banana_3mass/banana_3mass_pylink.so')
# choose integrator
banana_3mass.use_Qmc(verbosity=0,minn=10**6,maxeval=1,transform='korobov2')
# integrator settings used to run the timings
#banana_3mass.use_Qmc(verbosity=2,minn=10**5,maxeval=10**5,transform='korobov2')
#banana_3mass.use_Qmc(verbosity=2,minn=10**5,maxeval=10**5,transform='korobov2',devices=[-1])
#banana_3mass.use_Vegas(flags=2,maxeval=10**6,epsrel=1e-100,epsabs=1e-100)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = banana_3mass(real_parameters=[30.0,1.0,1.3,0.7], deformation_parameters_maximum=0.1, verbose=True)
# print results
print('Numerical Result')
print('integral without prefactor', str_integral_without_prefactor)
print('prefactor', str_prefactor)
print('integral with prefactor', str_integral_with_prefactor)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
hypergeo5F4 = IntegralLibrary('hypergeo5F4/hypergeo5F4_pylink.so')
# choose integrator
hypergeo5F4.use_Qmc()
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = hypergeo5F4(
[0.5], epsrel=1e-4, 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*'))
integral_with_prefactor_err = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
prefactor = sp.sympify(str_prefactor)
integral_without_prefactor = sp.sympify(
class CheckLib(unittest.TestCase):
def setUp(self):
# load c++ library
self.lib = IntegralLibrary('../issue7/issue7_pylink.so')
# set global options
self.real_parameters = [0.1]
self.complex_parameters = []
self.maxeval = 10**6
self.epsrel = 1e-4
self.epsabs = 1e-7
self.target_result_with_prefactor = \
{
-1: -3.1415926535897932385 + 0.0j, # eps ** -1
}
self.order_min_1 = -1
self.order_max_1 = -1
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
if target_series[order].real != 0.0:
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
if target_series[order].real == 0.0:
self.assertLessEqual(error.real,
max(abs(epsrel * value), epsabs))
else:
self.assertLessEqual(error.real, abs(epsrel * value.real))
if target_series[order].imag == 0.0:
self.assertLessEqual(error.imag,
max(abs(epsrel * value), epsabs))
else:
self.assertLessEqual(error.imag, abs(epsrel * value.imag))
# check integral value
if target_series[order].real == 0.0:
self.assertAlmostEqual(
value.real,
target_series[order].real,
delta=max(3. * epsrel * abs(target_series[order]),
3. * epsabs))
else:
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=max(3. * epsrel * abs(target_series[order]),
3. * epsabs))
else:
self.assertAlmostEqual(value.imag,
target_series[order].imag,
delta=3. * epsrel *
abs(target_series[order].imag))
def test_Qmc(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, self.order_min_1, self.order_max_1)
msq = complex(msq)
s = 0
for j in range(1, 1 + order):
s -= pow(msq / psq, j) / j
return (s + np.log(-psq / msq)) / psq
if __name__ == "__main__":
psq, msq = 4, 0.002
name = "bubble1L_dotted_z"
real_parameters = [psq, msq, 1] # z set to 1
# load c++ library
intlib = IntegralLibrary(f"{name}/{name}_pylink.so".format(name))
intlib.use_Qmc(transform="korobov3")
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = intlib(
real_parameters)
# convert the result to sympy expressions
result, error = map(sp.sympify,
series_to_sympy(str_integral_with_prefactor))
# access and print individual terms of the expansion
print("Numerical Result")
for power in [-2, -1, 0]:
val = complex(result.coeff("eps", power))
err = complex(error.coeff("eps", power))
print(f"eps^{power:<2} {val: .5f} +/- {err:.5e}")
temp3 = 3 * topmass * topmass * s3
temp4 = 3 * topmass * topmass * s3 * s1 * s2
output1 = 4 / temp3
output2 = 4 / temp1
output3 = 4 / temp2
output4 = (4 * (s1 * s2 + s2 * s3 + s1 * s3)) / temp4
if __name__ == "__main__":
# load c++ library
amp1 = IntegralLibrary('F212/F212_pylink.so')
amp2 = IntegralLibrary('F312/F312_pylink.so')
# choose Qmc integrator
# amp.use_Qmc() # Qmc doesnt work as of now for new version, try Vegas # amp.use_Vegas()
amp1.use_Qmc()
amp2.use_Qmc()
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = amp1(
[s1, s2, s3, topmass * topmass, hmass * hmass],
verbose=True,
epsrel=1e-4,
epsabs=1e-14) # [s12 , s13, s23, mtsq , mhsq]
# 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*')
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
int5 = IntegralLibrary('crossint5/crossint5_pylink.so')
# choose integrator
#int5.use_Vegas(nstart=10**5, nincrease=5*10**4, epsrel=1e-3, epsabs=1e-7, maxeval=10**6, real_complex_together=True, flags=2) # ``flags=2``: verbose --> see Cuba manual
int5.use_Qmc(minn=10**8,
minm=64,
epsrel=1e-3,
epsabs=1e-5,
maxeval=10**10,
verbosity=3,
devices=[0, 1, 2, 3],
cudablocks=128,
cudathreadsperblock=64,
transform='korobov3')
number_of_real_parameters = int(int5.info['number_of_real_parameters'])
number_of_complex_parameters = int(
int5.info['number_of_complex_parameters'])
with open('kinematics.input') as f:
with open('results_crossint5.out', 'w') as resultsfile:
for line in f:
point = line.split()
assert len(
point
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
box = IntegralLibrary('ladder2g/ladder2g_pylink.so')
# choose integrator
box.use_Qmc(verbosity=2, minn=10**7, maxeval=1, transform='korobov3')
# integrator settings used to run the timings
#box.use_Qmc(verbosity=2,minn=10**6,maxeval=1,transform='korobov3',fitfunction='polysingular')
#box.use_Qmc(verbosity=2,minn=10**5,maxeval=1,transform='korobov3',fitfunction='polysingular',devices=[-1])
#box.use_Vegas(flags=2,maxeval=10**6,epsrel=1e-100,epsabs=1e-100)
# integrate non-Euclidean point;
# s12, s23, s34, s45, s51, msq, mhsq = [2408664.483714835,-554153.4928655404,1496874.6133096598,735785.915792151,-517267.51076904044,256998.,41487.7]
s12, s23, s34, s45, s51, msq, mhsq = [
512775.5889493924, -75616.7189298124, 211810.77151387237,
187097.41183131794, -198221.48657428243, 256998., 41487.7
]
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = \
box([s12/s12,s23/s12,s34/s12,s45/s12,s51/s12,msq/s12,mhsq/s12],number_of_presamples=10**7)
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(
',', '+I*')
str_prefactor = str_prefactor.replace(',', '+I*')
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
name = 'triangle2L_largem_ebr'
intlib = IntegralLibrary(f'{name}/{name}_pylink.so')
intlib.use_Qmc(transform='korobov3',
epsrel=1e-4,
minn=50000,
maxeval=100000000)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = intlib(
real_parameters=[0.002, 4], verbose=True)
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(
',', '+I*')
# convert result to sympy expressions
integral_result = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
integral_result_err = sp.sympify(
str_integral_with_prefactor.replace('+/-', '*value+error*'))
# examples how to access individual orders
print('Numerical Result')
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
if __name__ == "__main__":
# load c++ library
bubble_6L = IntegralLibrary('bubble6L/bubble6L_pylink.so')
# choose integrator
bubble_6L.use_Qmc(verbosity=2,
minn=10**7,
maxeval=1,
transform='korobov3',
fitfunction='polysingular')
# integrator settings used to run the timings
#bubble_6L.use_Qmc(verbosity=2,minn=10**6,maxeval=1,transform='baker',fitfunction='polysingular')
#bubble_6L.use_Qmc(verbosity=2,minn=4*10**4,maxeval=1,transform='baker',fitfunction='polysingular',devices=[-1])
#bubble_6L.use_Vegas(flags=2,maxeval=10**5,epsrel=1e-100,epsabs=1e-100)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = bubble_6L(
)
# examples how to access individual orders
print('Numerical Result')
print('integral without prefactor', str_integral_without_prefactor)
print('prefactor', str_prefactor)
print('integral with prefactor', str_integral_with_prefactor)
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
import math
from pySecDec.integral_interface import IntegralLibrary
# Analytic result (for comparison)
def yyyy1L_analytic(t, u):
s = -t - u
ltu = math.log(t / u)
return -8*( 1 + (t-u)/s*ltu + (t*t + u*u)/(2*s*s)*\
( math.pi*math.pi + ltu**2 ) )
if __name__ == "__main__":
# load c++ library
amp = IntegralLibrary('yyyy1L/yyyy1L_pylink.so')
# choose Qmc integrator
amp.use_Qmc()
# integrate
_, _, result = amp([-1.3, -0.8]) # t, u
# print result
print('Numerical Result:', result)
print('Analytic Result:', yyyy1L_analytic(-1.3, -0.8))
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)
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
triangle2L = IntegralLibrary('ff3_massive/ff3_massive_pylink.so')
# choose integrator
#triangle2L.use_Vegas(nstart=10**4, maxeval=10**8, flags=2, real_complex_together=True) # ``flags=2``: verbose --> see Cuba manual
#triangle2L.use_Suave(maxeval=10**5, flags=2, real_complex_together=True) # ``flags=2``: verbose --> see Cuba manual
triangle2L.use_Qmc(verbosity=3,
cudablocks=1024,
cudathreadsperblock=256,
minn=10**7,
transform='baker',
epsrel=1e-4,
epsabs=1e-7,
maxeval=10**6,
maxmperpackage=16)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = triangle2L(
real_parameters=[0.72135, 1.0],
number_of_presamples=1000000,
deformation_parameters_maximum=0.1,
deformation_parameters_minimum=1e-10,
together=True)
print('Numerical Result')
print(str_integral_without_prefactor)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
if __name__ == "__main__":
# load c++ library
box2L = IntegralLibrary('Nbox2L_split_c/Nbox2L_split_c_pylink.so')
# choose integrator
box2L.use_Qmc(verbosity=0,
minn=15173222401,
maxeval=1,
transform='korobov3',
generatingvectors='cbcpt_cfftw1_6')
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = box2L(
real_parameters=[-1.0, -0.8, 0.1], verbose=True)
# print results
print('Numerical Result')
print('integral without prefactor', str_integral_without_prefactor)
print('prefactor', str_prefactor)
print('integral with prefactor', str_integral_with_prefactor)
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)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
pentabox = IntegralLibrary('pentabox_fin/pentabox_fin_pylink.so')
# choose integrator
pentabox.use_Qmc(verbosity=0,
minn=10**8,
maxeval=1,
transform='korobov3',
fitfunction='polysingular')
# integrator settings used to run the timings
#pentabox.use_Qmc(verbosity=2,minn=10**6,maxeval=1,transform='korobov3',fitfunction='polysingular')
#pentabox.use_Qmc(verbosity=2,minn=10**5,maxeval=1,transform='korobov3',fitfunction='polysingular',devices=[-1])
#pentabox.use_Vegas(flags=2,maxeval=10**6,epsrel=1e-100,epsabs=1e-100)
# integrate non-Euclidean point;
s12, s23, s34, s45, s51 = [5., -4., 2., -6., 3.]
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = pentabox(
[s12, s23, s34, s45, s51],
deformation_parameters_maximum=0.1,
verbose=True)
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(
',', '+I*')
from pySecDec.integral_interface import IntegralLibrary
if __name__ == "__main__":
# load c++ library
ff = IntegralLibrary('formfactor4L/formfactor4L_pylink.so')
# choose integrator
ff.use_Qmc(
minn=35 * 10**5,
# settings used for timings
#minn=5*10**3, devices = [-1],
#minn=2*10**5,
maxeval=1,
minm=64,
cudablocks=128,
cudathreadsperblock=64,
maxnperpackage=8,
maxmperpackage=8,
verbosity=2,
transform='baker',
fitfunction='polysingular',
)
#ff.use_Vegas(flags=2,maxeval=10**5,epsrel=1e-100,epsabs=1e-100) # used for timings
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = ff(
verbose=True)
# print results
print('Numerical Result')
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
bowtie = IntegralLibrary('bowtie/bowtie_pylink.so')
# choose integrator
bowtie.use_Qmc(verbosity=3,
devices=[-1, 0, 1, 2, 3],
minn=10**8,
transform='korobov3')
#bowtie.use_Vegas(flags=2,epsrel=1e-2,epsabs=1e-10,nstart=10000,nincrease=1000,maxeval=10000000) #
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = bowtie(
real_parameters=[10.0, -0.75, 1.0])
# 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*'))
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
hyperelliptic = IntegralLibrary('hyperelliptic/hyperelliptic_pylink.so')
# choose integrator
hyperelliptic.use_Qmc(verbosity=0,maxeval=1,minn=10**8,transform='korobov3',fitfunction='polysingular')
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = hyperelliptic(real_parameters=[10.0, -0.75, 1.0, 1.3, 0.7], 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*'))
integral_with_prefactor_err = sp.sympify(str_integral_with_prefactor.replace('+/-','*value+error*'))
prefactor = sp.sympify(str_prefactor)
integral_without_prefactor = sp.sympify(str_integral_without_prefactor.replace('+/-','*value+error*'))
integral_without_prefactor_err = sp.sympify(str_integral_without_prefactor.replace('+/-','*value+error*'))
# examples how to access individual orders
print('Numerical Result')
print('prefactor', prefactor)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
elliptic2L_physical = IntegralLibrary(
'elliptic2L_physical/elliptic2L_physical_pylink.so')
# choose integrator
elliptic2L_physical.use_Qmc(verbosity=0,
minn=2147483647,
maxeval=1,
transform='korobov1',
fitfunction='polysingular')
# integrator settings used to run the timings
#elliptic2L_physical.use_Qmc(verbosity=2,minn=3*10**6,maxeval=3*10**6,transform='korobov1',fitfunction='polysingular')
#elliptic2L_physical.use_Qmc(verbosity=2,minn=3*10**6,maxeval=3*10**6,transform='korobov1',fitfunction='polysingular',devices=[-1])
#elliptic2L_physical.use_Vegas(flags=2,maxeval=3*10**7,epsrel=1e-100,epsabs=1e-100)
# integrate non-Euclidean point;
s, t, pp4, msq = [90., -2.5, 1.6, 1.]
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = elliptic2L_physical(
[s, t, pp4, msq], verbose=True)
# convert complex numbers from c++ to sympy notation
str_integral_with_prefactor = str_integral_with_prefactor.replace(
',', '+I*')
class CheckLib(unittest.TestCase):
def setUp(self):
# load c++ library
self.lib = IntegralLibrary('../easy_sum/easy_sum_pylink.so')
# set global options
self.real_parameters = [0.1]
self.complex_parameters = []
self.maxeval = 10**6
self.epsrel = 1e-4
self.epsabs = 1e-7
self.target_result_with_prefactor_1 = \
{
-1: 0.2 + 0.0j, # eps ** -1
0: 0.22962348064032504712 + 0.0j, # eps ** 0
}
self.order_min_1 = -1
self.order_max_1 = 0
self.target_result_with_prefactor_2 = \
{
-2: 0.05 + 0.0j, # eps ** -2
-1: 0.015342640972002734529 + 0.0j, # eps ** -1
0: 0.0033313156240476989125 + 0.0j, # eps ** 0
}
self.order_min_2 = -2
self.order_max_2 = 0
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
if target_series[order].real != 0.0:
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
if target_series[order].real == 0.0:
self.assertLessEqual(error.real,
max(abs(epsrel * value), epsabs))
else:
self.assertLessEqual(error.real, abs(epsrel * value.real))
if target_series[order].imag == 0.0:
self.assertLessEqual(error.imag,
max(abs(epsrel * value), epsabs))
else:
self.assertLessEqual(error.imag, abs(epsrel * value.imag))
# check integral value
if target_series[order].real == 0.0:
self.assertAlmostEqual(
value.real,
target_series[order].real,
delta=max(3. * epsrel * abs(target_series[order]),
3. * epsabs))
else:
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=max(3. * epsrel * abs(target_series[order]),
3. * epsabs))
else:
self.assertAlmostEqual(value.imag,
target_series[order].imag,
delta=3. * epsrel *
abs(target_series[order].imag))
def test_Qmc(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)
str_integral_with_prefactor_1, str_integral_with_prefactor_2 = str_integral_with_prefactor.strip(
).split('\n')
# check integral
self.check_result(str_integral_with_prefactor_1,
self.target_result_with_prefactor_1, self.epsrel,
self.epsabs, self.order_min_1, self.order_max_1)
self.check_result(str_integral_with_prefactor_2,
self.target_result_with_prefactor_2, self.epsrel,
self.epsabs, self.order_min_2, self.order_max_2)
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary, series_to_sympy
import sympy as sp
if __name__ == "__main__":
# load c++ library
name = "bubble1L_ebr_large_mass"
bubble1L = IntegralLibrary(f"{name}/{name}_pylink.so")
bubble1L.use_Qmc(transform="korobov3", verbosity=1)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = bubble1L(
real_parameters=[0.002, 4])
# convert the result to sympy expressions
result, error = map(sp.sympify,
series_to_sympy(str_integral_with_prefactor))
# examples how to access individual orders
print('Numerical Result')
for power in [-1, 0]:
valreal, valimg = result.coeff('eps', power).as_real_imag()
errreal, errimg = error.coeff('eps', power).as_real_imag()
print("eps^{:<2} {: .15f}{:+.15f}*I +/- {:.15f}{:+.15f}*I".format(
power, float(valreal), float(valimg), float(errreal),
float(errimg)))
#!/usr/bin/env python3
from pySecDec.integral_interface import IntegralLibrary
import sympy as sp
if __name__ == "__main__":
# load c++ library
HZ2L_nonplanar = IntegralLibrary('hz2L_nonplanar/hz2L_nonplanar_pylink.so')
# choose integrator
HZ2L_nonplanar.use_Qmc(verbosity=0, maxeval=10**6, transform='korobov3')
# integrator settings used to run the timings
#HZ2L_nonplanar.use_Qmc(verbosity=2,minn=10**6,maxeval=10**6,transform='korobov3')
#HZ2L_nonplanar.use_Qmc(verbosity=2,minn=10**5,maxeval=10**5,transform='korobov3',devices=[-1])
#HZ2L_nonplanar.use_Vegas(flags=2,maxeval=5*10**5,epsrel=1e-100,epsabs=1e-100)
# integrate
str_integral_without_prefactor, str_prefactor, str_integral_with_prefactor = HZ2L_nonplanar(
real_parameters=[200., -23., 9., 1.56, 0.81], 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(
