def test_gh295():
def f(x):
return 1e-20 * numpy.sin(x)
# import scipy.integrate
# out = scipy.integrate.quad(f, 0.0, 1.0, epsabs=0.0, epsrel=1.0e-10)
quadpy.quad(f, 0.0, 1.0, epsabs=1.0e-8, epsrel=1.0e-8)
def test_infinite_limits():
tol = 1.0e-9
val, err = quadpy.quad(lambda x: numpy.exp(-(x**2)), -numpy.inf, numpy.inf)
assert abs(val - numpy.sqrt(numpy.pi)) < tol
assert err < tol
val, err = quadpy.quad(lambda x: numpy.exp(-x), 0.0, numpy.inf)
assert abs(val - 1.0) < tol
assert err < tol
val, err = quadpy.quad(lambda x: numpy.exp(+x), -numpy.inf, 0)
assert abs(val - 1.0) < tol
assert err < tol
def calculate_nth_constant(
n: int, constant_func: FLOAT_TO_COMPLEX) -> complex:
def array_f(array: np.array):
return np.array(list(map(constant_func, array)))
return quad(array_f, 0., 1., limit=30000)[0]
def test_236():
# https://github.com/nschloe/quadpy/issues/236
def f(x):
return numpy.exp(-1.0 / (1 - x**2))
val, err = quadpy.quad(f, -1, 1)
assert err < 1.0e-9
def test_245():
# https://github.com/nschloe/quadpy/issues/245
def f(x):
return x + x * 1j
val, err = quadpy.quad(f, 0, 1)
assert err < 1.0e-9
def test_args():
val, err = quadpy.quad(lambda x, a: numpy.sin(a * x) - x,
0.0,
6.0,
args=(1, ))
ref = -17 - numpy.cos(6)
assert abs(val - ref) < 1.0e-8 * abs(ref)
def test_complex_valued():
def f(x):
return numpy.exp(1j * x)
# import scipy.integrate
# out = scipy.integrate.quad(f, 0.0, 1.0, epsabs=0.0, epsrel=1.0e-10)
val, _ = quadpy.quad(f, 0.0, 1.0, epsabs=1.0e-8, epsrel=1.0e-8)
exact = numpy.sin(1.0) - 1j * (numpy.cos(1.0) - 1.0)
assert numpy.abs(val - exact) < 1.0e-10
def test_gh255a():
# https://github.com/nschloe/quadpy/issues/255
T = 2 * numpy.pi
def ex1(t):
return numpy.where(numpy.logical_and((t % T >= 0), (t % T < numpy.pi)),
t % T, numpy.pi)
a = 3.15
val, err = quadpy.quad(ex1, 0.0, a, epsabs=1.0e-13)
ref = 0.5 * numpy.pi**2 + (a - numpy.pi) * numpy.pi
assert abs(val - ref) < 1.0e-8 * abs(ref), "\n" + "\n".join([
f"reference = {ref}", f"computed = {val}",
f"error = {abs(val-ref)}"
])
def test_gh255b():
# https://github.com/nschloe/quadpy/issues/255
T = 2 * numpy.pi
def ex1(t):
return numpy.where(numpy.logical_and((t % T >= 0), (t % T < numpy.pi)),
t % T, numpy.pi)
a = 6.3
val, err = quadpy.quad(ex1, 0.0, a, epsabs=1.0e-13, limit=100)
# ref = 14.804547973620716
ref = 1.5 * numpy.pi**2 + (a - 2 * numpy.pi)**2 / 2
assert abs(val - ref) < 1.0e-8 * abs(ref), "\n" + "\n".join([
f"reference = {ref}", f"computed = {val}",
f"error = {abs(val-ref)}"
])
def test_sin_x():
val, err = quadpy.quad(lambda x: numpy.sin(x) - x, 0.0, 6.0)
ref = -17 - numpy.cos(6)
assert abs(val - ref) < 1.0e-8 * abs(ref)
def V(x):
return qp.quad(compute_2, low, high, args=(x, ))[0]
def quad_fn(x):
v, e = quad(x, a=self.int_lower, b=self.int_upper)
assert np.all(e < 1e-6)
return v
def test_x():
val, _ = quadpy.quad(lambda x: x, -1.0, 1.0)
exact = 0.0
assert abs(exact - val) < 1.0e-10
def test_ln():
val, err = quadpy.quad(lambda x: numpy.log(x), 0.5, 5.0)
ref = (numpy.log(5) * 5 - 5) - (numpy.log(0.5) * 0.5 - 0.5)
assert abs(val - ref) < 1.0e-8 * abs(ref)
def test_vector():
val, err = quadpy.quad(lambda x: [numpy.sin(x) - x, x], 0.0, 6.0)
ref = [-17 - numpy.cos(6), 18]
assert numpy.all(numpy.abs(val - ref) < 1.0e-8 * numpy.abs(ref))
def pi_hat_star(u, x): # action given state
numerator = compute(u, x)
denominator = qp.quad(compute, low, high, args=(x, ))[0]
return numerator / denominator
def Fish(cosmo,
kmin,
kmax,
data,
iz,
recon,
derPalpha,
BAO_only=True,
GoFast=False):
""" Computes the Fisher information on cosmological parameters biases*sigma8, fsigma8, alpha_perp and alpha_par
for a given redshift bin by integrating a separate function (CastNet) over k and mu.
Parameters
----------
cosmo: CosmoResults object
An instance of the CosmoResults class. Holds the power spectra, BAO damping parameters and
other cosmological parameters such as f and sigma8 as a function of redshift.
data: InputData object
An instance of the InputData class. Holds the galaxy bias and number density for each sample
as a function of redshift
iz: int
The index of the redshift bin we are considering. Used to access the correct parts of data,
cosmo, recon.
recon: np.ndarray
An array containing the expected reduction in BAO damping scales at each redshift. Pre-computed
using the compute_recon function.
derPalpha: list
A list containing 2 scipy.interpolate.RegularGridInterpolator instances. Each one holds an object that
can be called to return the derivative of power spectrum (full or BAO_only) at a particular k or mu
value. The first element in the list is dP(k')/alpha_perp, the second is dP(k')/dalpha_par
BAO_only: logical
If True compute derivatives w.r.t. to alpha_perp and alpha_par using only the BAO feature in the
power spectra. Otherwise use the full power spectrum and the kaiser factor. The former matches a standard
BAO analysis, the latter is more akin to a 'full-shape' analysis. Default = True
GoFast: logical
If True uses Simpson's rule for the k and mu integration with 400 k-bins and 100 mu-bins, so fast but
but approximate. Otherwise, use vector-valued quadrature integration. This latter option can be very slow for
many tracers. Default = False.
Returns
-------
ManyFish: np.ndarray
The complete Fisher information on the parameters [b_0*sigma8 ... b_npop*sigma8], fsigma8, alpha_perp, alpha_par
at the redshift corresponding to index iz. Has size (npop + 3)
"""
npop = np.shape(data.nbar)[0]
npk = int(npop * (npop + 1) / 2)
# Uses Simpson's rule or adaptive quadrature to integrate over all k and mu.
if GoFast:
# mu and k values for Simpson's rule
muvec = np.linspace(0.0, 1.0, 100)
kvec = np.linspace(kmin, kmax, 400)
# 2D integration
ManyFish = simps(
simps(CastNet(muvec, kvec, iz, npop, npk, data, cosmo, recon,
derPalpha, BAO_only),
x=muvec,
axis=-1),
x=kvec,
axis=-1,
)
else:
# Integral over mu
OneFish = lambda *args: quad(CastNet,
0.0,
1.0,
args=args,
limit=1000,
epsabs=1.0e-5,
epsrel=1.0e-5)[0]
# Integral over k
ManyFish = quad(
OneFish,
kmin,
kmax,
args=(iz, npop, npk, data, cosmo, recon, derPalpha, BAO_only),
limit=1000,
epsabs=1.0e-5,
epsrel=1.0e-5,
)[0]
# Multiply by the necessary prefactors
ManyFish *= cosmo.volume[iz] / (2.0 * np.pi**2)
return ManyFish
for i in range(3):
funr = lambda theta,r,z: (P_theta[i](theta)*np.cos(theta)*np.sin(theta)*special.jv(1,k*r*np.sin(theta))*np.exp(1j*k*z*np.cos(theta)))
funphi = lambda theta,r,z: (P_theta[i](theta)*np.sin(theta)*special.jv(1,k*r*np.sin(theta))*np.exp(1j*k*z*np.cos(theta)))
funz = lambda theta,r,z: (P_theta[i](theta)*np.cos(theta)*np.sin(theta**2)*special.jv(0,k*r*np.sin(theta))*np.exp(1j*k*z*np.cos(theta)))
z=0
I_phi = np.zeros((len(xArray),len(yArray)), dtype = complex)
I_r = np.zeros((len(xArray),len(yArray)), dtype = complex)
I_z = np.zeros((len(xArray),len(yArray)), dtype = complex)
for l in range(len(xArray)):
for m in range(len(yArray)):
r = np.sqrt(xArray[l]**2+yArray[m]**2)
I_r[l,m] = quadpy.quad(lambda t: funr(t,r,z), 0, theta_max)[0]
I_phi[l,m] = quadpy.quad(lambda t: funphi(t,r,z), 0, theta_max)[0]
I_z[l,m] = quadpy.quad(lambda t: funz(t,r,z), 0, theta_max)[0]
BeamResults[6*i+0] = np.abs(coeff*np.cos(varphi0)*np.real_if_close(I_r))**2 #E_rxy^2;
BeamResults[6*i+1] = np.abs(coeff*np.sin(varphi0)*np.real_if_close(I_phi))**2 #E_phixy^2
BeamResults[6*i+2] = np.abs(1j*coeff*np.cos(varphi0)*np.real_if_close(I_z))**2#E_zxy^2
for l in range(len(zArray)):
z = zArray[l]
for m in range(len(rArray)):
r = rArray[m]
I_r[l,m] = quadpy.quad(lambda t: funr(t,r,z), 0, theta_max)[0]
I_phi[l,m] = quadpy.quad(lambda t: funphi(t,r,z), 0, theta_max)[0]
I_z[l,m] = quadpy.quad(lambda t: funz(t,r,z), 0, theta_max)[0]
return probs
# return observable_fn(conf, lj_params)*np.exp(-U/kT)
temperature = 300.0
kT = BOLTZ * temperature
int_lower = 0.01
int_upper = 0.99
Z_integrand = functools.partial(pdf,
observable_fn=lambda conf, params: 1.0,
kT=kT)
# compute the partition function with observable returning identity
Z, Z_err = quad(Z_integrand, int_lower, int_upper)
print("Z", Z)
# return the coordinate of the particle
avg_x_integrand = functools.partial(
pdf, observable_fn=lambda conf, params: conf[1][0], kT=BOLTZ * temperature)
avg_x = quad(avg_x_integrand, int_lower, int_upper)[0] / Z # 0.50000
print("<O(x)>", avg_x)
# deriv w.r.t. the 0.1 value in sigma
avg_du_dp_integrand = functools.partial(
pdf,
observable_fn=lambda conf, params: dU_dp(conf, params)[0],
import math
import scipy.integrate as sci
import scipy as sc
import cmath
import numpy as np
import quadpy
#val = sci.quad(lambda t: cmath.e ** (-2 * cmath.pi * t * complex(0, 1)), 0, 1)[0].real
def f(t):
return cmath.e**(4 * cmath.pi * t * complex(0, 1))
result = quadpy.quad(f, 0, 1)
print(result[0].imag)
other = result[0] * cmath.e**(-2 * cmath.pi * 2)
def test_sin_x_other_way():
val, err = quadpy.quad(lambda x: numpy.sin(x) - x, 1.0, 0.0)
# import scipy.integrate
# val, err = scipy.integrate.quad(lambda x: numpy.sin(x) - x, 1.0, 0.0)
ref = -0.5 + numpy.cos(1)
assert abs(val - ref) < 1.0e-8 * abs(ref)
action_bounds,
reward,
timesteps=5,
lamb=100)
#%%
start_state = X[:, 0]
# possible_actions = [2.77, 1, 5, 12, 8.95]
possible_actions = np.arange(0, bound + 0.5, 0.5)
for possible_action in possible_actions:
print(f"{possible_action}:", pi(possible_action, start_state))
print(f"{-possible_action}:", pi(-possible_action, start_state))
# I think -8.95 is the 'right' one
# %%
int_pi = qp.quad(pi, action_bounds[0], action_bounds[1],
args=(start_state, ))[0]
assert (int_pi == 1.0)
#%% Dictionary functions
psi = observables.monomials(6)
#%% Variable definitions
mu = -0.1
lamb = 1
A = np.array([[mu, 0], [0, lamb]])
A2 = np.array([[mu, 0, 0], [0, lamb, -lamb], [0, 0, 2 * mu]])
B = np.array([[0], [1]])
D_y = np.append(B, [[0]], axis=0)
Q = np.identity(2)
Q2 = np.identity(3)
R = 1
