class UniformMask(parameter.Parameter):
_size = len(mask) #size
_prior = parameter.Function(UniformMaskPrior, pmin=pmin,
pmax=pmax, mask=mask)
_sampler = staticmethod(UniformMaskSampler)
_typename = parameter._argrepr("UniformMask", pmin=pmin, pmax=pmax,
mask=mask)
class InvGamma(parameter.Parameter):
_size = size
_prior = parameter.Function(InvGammaPrior, alpha=alpha, gamma=gamma)
_sampler = staticmethod(InvGammaSampler)
_alpha = alpha
_gamma = gamma
def __repr__(self):
return '"{}": InvGamma({},{})'.format(self.name, alpha, gamma) + (
"" if self._size is None else "[{}]".format(self._size)
)
def test_powerlaw(self):
def powerlaw(f, log10_A=-15):
return (10**log10_A) * f**2
pl = parameter.Function(powerlaw, log10_A=parameter.Uniform(0, 5))
pl1 = pl('pl1')
repr_A = 'pl1(pl1_log10_A:Uniform(pmin=0, pmax=5))'
repr_B = 'pl1(pl1_log10_A:Uniform(pmax=5, pmin=0))'
assert str(pl1) == repr_A or str(pl1) == repr_B
fs = np.array([1, 2, 3])
assert np.allclose(pl1(fs), np.array([1e-15, 4e-15, 9e-15]))
assert np.allclose(pl1(fs, log10_A=-16),
np.array([1e-16, 4e-16, 9e-16]))
assert np.allclose(pl1(fs, params={'pl1_log10_A': -17}),
np.array([1e-16, 4e-16, 9e-16]))
def log10(A=10**-16):
return np.log10(A)
log10f = parameter.Function(log10,
A=parameter.Uniform(10**-17, 10**-14))
pm = parameter.Function(powerlaw, log10_A=log10f)
pm1 = pm('pm1')
repr_A = 'pm1(pm1_log10_A_A:Uniform(pmin=1e-17, pmax=1e-14))'
repr_B = 'pm1(pm1_log10_A_A:Uniform(pmax=1e-14, pmin=1e-17))'
assert str(pm1) == repr_A or str(pm1) == repr_B
assert np.allclose(pm1(fs, log10_A=-13),
np.array([1e-13, 4e-13, 9e-13]))
assert np.allclose(pm1(fs, params={'pm1_log10_A_A': 10**-19}),
np.array([1e-19, 4e-19, 9e-19]))
def test_Function_of_Function(self):
def doub(x):
return 2 * x
f = parameter.Function(doub, x=parameter.Uniform(0, 1))
def mult(a, w=2, z=1):
return a * w * z
g = parameter.Function(mult, w=parameter.Uniform(2, 3), z=f)
g1 = g('g1')
repr_A = 'g1_w:Uniform(pmin=2, pmax=3)'
repr_B = 'g1_w:Uniform(pmax=3, pmin=2)'
assert isinstance(g1, parameter.FunctionBase)
assert (sorted(map(str, g1.params))[0] == repr_A
or sorted(map(str, g1.params))[0] == repr_B)
assert g1(2, z=3) == 12
assert g1(2, w=10, z=3) == 60
assert g1(2, params={'g1_z_x': 5, 'g1_w': 10}) == 200
def __init__(self, psr):
super(BasisCommonGP, self).__init__(psr)
self.name = self.psrname + "_" + self.signal_id
pname = "_".join([psr.name, name])
self._bases = basisFunction(pname, psr=psr)
self._params, self._coefficients = {}, {}
for par in itertools.chain(self._prior._params.values(),
self._orf._params.values(),
self._bases._params.values()):
self._params[par.name] = par
rand_state = np.int(np.abs(np.sum(psr.pos)) * 10000)
ra = uniform.rvs(loc=0, scale=2 * np.pi, random_state=rand_state)
dec = cosine.rvs(loc=0, scale=0.5, random_state=rand_state + 11)
newpos = np.array(SkyCoord(ra=ra*u.rad, \
dec=dec*u.rad).cartesian.xyz)
self._psrpos = psr.pos
self._psrpos_scrambled = newpos
if coefficients:
self._construct_basis()
# if we're given an instantiated coefficient vector
# that's what we will use
if isinstance(coefficients, parameter.Parameter):
self._coefficients[""] = coefficients
self._params[coefficients.name] = coefficients
return
chain = itertools.chain(self._prior._params.values(),
self._orf._params.values(),
self._bases._params.values())
priorargs = {par.name: self._params[par.name] for par in chain}
logprior = parameter.Function(self._get_coefficient_logprior,
**priorargs)
size = self._basis.shape[1]
cpar = parameter.GPCoefficients(
logprior=logprior, size=size)(pname + "_coefficients")
self._coefficients[""] = cpar
self._params[cpar.name] = cpar
def _do_selection(self, psr, priorfn, basisfn, coefficients,
selection):
sel = selection(psr)
self._keys = list(sorted(sel.masks.keys()))
self._masks = [sel.masks[key] for key in self._keys]
self._prior, self._bases = {}, {}
self._params, self._coefficients = {}, {}
for key, mask in zip(self._keys, self._masks):
pnames = [psr.name, name, key]
pname = '_'.join([n for n in pnames if n])
self._prior[key] = priorfn(pname, psr=psr)
self._bases[key] = basisfn(pname, psr=psr)
for par in itertools.chain(self._prior[key]._params.values(),
self._bases[key]._params.values()):
self._params[par.name] = par
if coefficients and pyv3:
# we can only create GPCoefficients parameters if the basis
# can be constructed with default arguments
# (and does not change size)
self._construct_basis()
for key in self._keys:
pname = '_'.join([n for n in [psr.name, name, key] if n])
chain = itertools.chain(self._prior[key]._params.values(),
self._bases[key]._params.values())
priorargs = {
par.name: self._params[par.name]
for par in chain
}
logprior = parameter.Function(
functools.partial(self._get_coefficient_logprior, key),
**priorargs)
size = self._slices[key].stop - self._slices[key].start
cpar = parameter.GPCoefficients(logprior=logprior,
size=size)(pname +
'_coefficients')
self._coefficients[key] = cpar
self._params[cpar.name] = cpar
def test_powerlaw_equad(self):
def powerlaw(f, log10_A=-15):
return (10**log10_A) * f**2
def log10(A=10**-16):
return np.log10(A)
fquad = white_signals.EquadNoise(log10_equad=parameter.Function(
log10, A=parameter.Uniform(10**-17, 10**-14)))
fquad1 = fquad(self.psr)
repr_A = '[B1855+09_log10_equad_A:Uniform(pmin=1e-17, pmax=1e-14)]'
repr_B = '[B1855+09_log10_equad_A:Uniform(pmax=1e-14, pmin=1e-17)]'
assert str(fquad1.params) == repr_A or str(fquad1.params) == repr_B
assert np.allclose(
fquad1.get_ndiag(params={'B1855+09_log10_equad_A': 10**-14})[:3],
np.array([1e-28, 1e-28, 1e-28]))
def __init__(self, psr):
super(BasisCommonGP, self).__init__(psr)
self.name = self.psrname + '_' + self.signal_id
pname = '_'.join([psr.name, name])
self._bases = basisFunction(pname, psr=psr)
self._params, self._coefficients = {}, {}
for par in itertools.chain(self._prior._params.values(),
self._orf._params.values(),
self._bases._params.values()):
self._params[par.name] = par
self._psrpos = psr.pos
if coefficients and pyv3:
self._construct_basis()
# if we're given an instantiated coefficient vector
# that's what we will use
if isinstance(coefficients, parameter.Parameter):
self._coefficients[''] = coefficients
self._params[coefficients.name] = coefficients
return
chain = itertools.chain(self._prior._params.values(),
self._orf._params.values(),
self._bases._params.values())
priorargs = {par.name: self._params[par.name] for par in chain}
logprior = parameter.Function(self._get_coefficient_logprior,
**priorargs)
size = self._basis.shape[1]
cpar = parameter.GPCoefficients(
logprior=logprior, size=size)(pname + '_coefficients')
self._coefficients[''] = cpar
self._params[cpar.name] = cpar
def test_enterprise_Function(self):
def add(a, x=1, y=2):
return a + x + y
x = parameter.Uniform(0, 1)
f = parameter.Function(add, x=x)
assert issubclass(f, parameter.FunctionBase)
f1 = f('f1')
repr_A = 'f1(f1_x:Uniform(pmin=0, pmax=1))'
repr_B = 'f1(f1_x:Uniform(pmax=1, pmin=0))'
assert isinstance(f1, parameter.FunctionBase)
assert str(f1) == repr_A or str(f1) == repr_B
assert len(f1.params) == 1
assert f1(2) == 5
assert f1(2, 0.5, 7) == 9.5
assert f1(2, x=0.5, y=7) == 9.5
assert f1(3, params={'f1_x': 4}) == 9
class ACE_SWEPAM_Parameter(parameter.Parameter):
_size = size
_typename = parameter._argrepr('ACE_SWEPAM')
_prior = parameter.Function(ACE_SWEPAM_Prior)
_sampler = staticmethod(ACE_SWEPAM_Sampler)
class Gamma(parameter.Parameter):
_size = size
_prior = parameter.Function(GammaPrior, a=a, loc=loc, scale=scale)
_sampler = staticmethod(GammaSampler)
_typename = parameter._argrepr("Gamma", a=a, loc=loc, scale=scale)
