def __init__(self, sigma, arroots, maroots):
self.arroots = np.atleast_1d(arroots).astype(np.complex128)
self.maroots = np.atleast_1d(maroots).astype(np.complex128)
self.p = len(arroots)
self.q = len(maroots)
if self.q >= self.p:
raise ValueError("q must be less than p")
if not np.all(self.arroots.real < 0.0):
raise ValueError("arroots must have a negative real part")
if not np.all(self.maroots.real <= 0.0):
raise ValueError("maroots must have a negative real part")
self.alpha = polyfromroots(self.arroots)
self.alpha /= self.alpha[-1]
self.beta = polyfromroots(self.maroots)
self.beta /= self.beta[0]
self.b = np.concatenate((self.beta, np.zeros(self.p - self.q - 1)))
U = np.atleast_1d(arroots)[None, :]**np.arange(self.p)[:, None]
self.b = np.dot(self.b, U)
e = np.zeros(self.p, dtype=np.complex128)
e[-1] = sigma
J = np.linalg.solve(U, e)
self.V = -J[:, None] * np.conjugate(J)[None, :]
self.V /= (self.arroots[:, None] + np.conjugate(self.arroots)[None, :])
self.reset()
def __init__(self, sigma, arroots, maroots):
self.arroots = np.atleast_1d(arroots).astype(np.complex128)
self.maroots = np.atleast_1d(maroots).astype(np.complex128)
self.p = len(arroots)
self.q = len(maroots)
if self.q >= self.p:
raise ValueError("q must be less than p")
if not np.all(self.arroots.real < 0.0):
raise ValueError("arroots must have a negative real part")
if not np.all(self.maroots.real <= 0.0):
raise ValueError("maroots must have a negative real part")
self.alpha = polyfromroots(self.arroots)
self.alpha /= self.alpha[-1]
self.beta = polyfromroots(self.maroots)
self.beta /= self.beta[0]
self.b = np.concatenate((self.beta, np.zeros(self.p - self.q - 1)))
U = np.atleast_1d(arroots)[None, :] ** np.arange(self.p)[:, None]
self.b = np.dot(self.b, U)
e = np.zeros(self.p, dtype=np.complex128)
e[-1] = sigma
J = np.linalg.solve(U, e)
self.V = -J[:, None] * np.conjugate(J)[None, :]
self.V /= (self.arroots[:, None] + np.conjugate(self.arroots)[None, :])
self.reset()
def linFromPZ(poles=[], zeros=[], gain=1.0, wgain=0, ingain=None):
"""
@linFromPZ
linFromPZ(poles,zeros,gain,ingain)
Creates a system from the list of poles and zeros
Parameters:
poles : List of poles
zeros : List of zeros
Gain can be defined as:
gain : Gain defined as the quotient of first num/den coef.
wgain : Frequency where gain is defined
igain : Gain defined at infinite freq. in high pass
Returns a linblk object
"""
# Create new block
s = linblk()
s.den = P.Polynomial(P.polyfromroots(poles))
s.num = P.Polynomial(P.polyfromroots(zeros))
# Add gain
if ingain == None:
#curr = s.gain()
curr = np.abs(s.eval(1j * wgain))
s.num = s.num * gain / curr
else:
curr = s.num.coef[-1] / s.den.coef[-1]
s.num = s.num * gain / curr
return s
def test_polyfromroots(self):
res = poly.polyfromroots([])
assert_almost_equal(trim(res), [1])
for i in range(1, 5):
roots = np.cos(np.linspace(-np.pi, 0, 2 * i + 1)[1::2])
tgt = Tlist[i]
res = poly.polyfromroots(roots) * 2 ** (i - 1)
assert_almost_equal(trim(res), trim(tgt))
def test_polyfromroots(self) :
res = poly.polyfromroots([])
assert_almost_equal(trim(res), [1])
for i in range(1,5) :
roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
tgt = Tlist[i]
res = poly.polyfromroots(roots)*2**(i-1)
assert_almost_equal(trim(res),trim(tgt))
def lsp_to_lpc(lsp):
"""Convert line spectral pairs to LPC"""
ps = np.concatenate((lsp[:, 0], -lsp[::-1, 0], [np.pi]))
qs = np.concatenate((lsp[:, 1], [0], -lsp[::-1, 1]))
p = np.cos(ps) - np.sin(ps) * 1.0j
q = np.cos(qs) - np.sin(qs) * 1.0j
p = np.real(P.polyfromroots(p))
q = -np.real(P.polyfromroots(q))
a = 0.5 * (p + q)
return a[:-1]
def __init__(self, real_part, imag_part):
self.real_part = real_part
if imag_part < 0:
self.imag_part = -imag_part
else:
self.imag_part = imag_part
# the polynomial is stored in standard order
if self.imag_part != 0.0:
self.poly_coef = polyfromroots([
np.complex(self.real_part, self.imag_part),
np.complex(self.real_part, -self.imag_part),
]).real
else:
self.poly_coef = polyfromroots([self.real_part]).real
def process(seed, K):
"""
K is model order / number of zeros
"""
print(K, end=" ")
# create the dirac locations with many, many points
rng = np.random.RandomState(seed)
tk = np.sort(rng.rand(K) * period)
# true zeros
uk = np.exp(-1j * 2 * np.pi * tk / period)
coef_poly = poly.polyfromroots(uk) # more accurate than np.poly
# estimate zeros
uk_hat = np.roots(np.flipud(coef_poly))
# place on unit circle?
uk_hat_unit = uk_hat / np.abs(uk_hat)
# compute error
min_dev_norm = distance(uk, uk_hat)[0]
_err_roots = 20 * np.log10(np.linalg.norm(uk) / min_dev_norm)
min_dev_norm = distance(uk, uk_hat_unit)[0]
_err_unit = 20 * np.log10(np.linalg.norm(uk) / min_dev_norm)
return _err_roots, _err_unit
def _build_index(self, L, client_id: str = None):
"""
This function takes as input:
o Keyword list `L`
o System parameter PM = {`self.PKs`, `self.SKg`}
This function outputs secure index `IL`
"""
# assert len(L) == self.PKs['l'], "Keyword list should be l long"
if client_id is None:
client_id = self.id
SKg = self.SKg
α = SKg['α']
roots = [int(α * hash_Zn(client_id, self.PKs['group']))]
for i in range(1, self.PKs['l']):
if i < len(L) + 1:
word = L[i - 1]
print(word)
else:
word = '⊥'
roots.append(int(α * hash_Zn(word, self.PKs['group'])))
polynomial_coefficients = list(polyfromroots(roots))
rs = num_Zn_star_not_one(self.PKs['q'], self.PKs['group'].random, ZR)
g = self.PKs['g']
IL = [
g**(rs * self.PKs['group'].init(ZR, i))
for i in polynomial_coefficients
]
return IL
def process(seed, K):
"""
K is model order / number of zeros
"""
# create the dirac locations with many, many points
rng = np.random.RandomState(seed)
tk = np.sort(rng.rand(K)*period)
# true zeros
uk = np.exp(-1j*2*np.pi*tk/period)
coef_poly = poly.polyfromroots(uk) # more accurate than np.poly
# estimate zeros
uk_hat = np.roots(np.flipud(coef_poly))
uk_hat_poly = poly.polyroots(coef_poly)
uk_hat_mpmath = mpmath.polyroots(np.flipud(coef_poly), maxsteps=100,
cleanup=True, error=False, extraprec=50)
# compute error
min_dev_norm = distance(uk, uk_hat)[0]
_err_roots = 20*np.log10(np.linalg.norm(uk)/min_dev_norm)
min_dev_norm = distance(uk, uk_hat_poly)[0]
_err_poly = 20*np.log10(np.linalg.norm(uk)/min_dev_norm)
# for mpmath, need to compute error with its precision
uk = np.sort(uk)
uk_mpmath = [mpmath.mpc(z) for z in uk]
uk_hat_mpmath = sorted(uk_hat_mpmath, key=cmp_to_key(compare_mpc))
dev = [uk_mpmath[k] - uk_hat_mpmath[k] for k in range(len(uk_mpmath))]
_err_mpmath = 20*mpmath.log(mpmath.norm(uk_mpmath) / mpmath.norm(dev),
b=10)
return _err_roots, _err_poly, _err_mpmath
def test_polyroots(self) :
assert_almost_equal(poly.polyroots([1]), [])
assert_almost_equal(poly.polyroots([1, 2]), [-.5])
for i in range(2,5) :
tgt = np.linspace(-1, 1, i)
res = poly.polyroots(poly.polyfromroots(tgt))
assert_almost_equal(trim(res), trim(tgt))
def newkey(sec=18, N=2):
'''
Generates a secret key with a security parameter sec.
sec parameter defines amount of complex roots of the private key's polynomial part.
Result of this function is a key with three fields: polynomial, base, secret encryption number.
:param sec: security parameter
:return: secret key object
'''
random.seed(SEED)
r = random.randint(2, N)
deg = nxtodd(sec)
sec = (int)((deg - 1) / 2)
roots = (random.randint(1, r), )
key = [0 for x in range(deg + 1)]
for i in range(sec):
roots += complexroot(r)
poly = nppp.polyfromroots(roots)
for d in range(deg + 1):
key[d] = int(poly[d].real)
key[0] += r
coefs = []
for i in range(len(key)):
coefs.append(key[i])
return (coefs, roots[0], r)
def __init__(self, poly_degree=7, numPoints = 300, numTrain = None, h5=None):
if h5 is not None:
self.h5read(h5)
return
assert poly_degree > 0, "must have at least 1 root"
if numTrain is None:
numTrain = max(1,int(.1 * numPoints))
assert 3*numTrain < numPoints, "numTrain must be < 3*numPoints to produce test/train/cv sets"
# make a polynomial with the given number of roots, but no root at 0
poly_roots = list(np.arange(poly_degree + 1) - int(poly_degree//2))
poly_roots.remove(0)
poly_roots = np.array(poly_roots)
poly_coeffs = polynomial.polyfromroots(poly_roots)
self.x_all = vec2columnMat(np.linspace(start = poly_roots[0],
stop = poly_roots[-1],
num = 300))
self.y_all = polynomial.polyval(self.x_all[:], poly_coeffs)
inds = range(len(self.x_all))
random.shuffle(inds)
self.x_train = vec2columnMat(self.x_all[:][inds[0:numTrain]])
self.y_train = vec2columnMat(self.y_all[:][inds[0:numTrain]])
self.x_test = vec2columnMat(self.x_all[:][inds[numTrain:(2*numTrain)]])
self.y_test = vec2columnMat(self.y_all[:][inds[numTrain:(2*numTrain)]])
self.x_cv = vec2columnMat(self.x_all[:][inds[(2*numTrain):(3*numTrain)]])
self.y_cv = vec2columnMat(self.y_all[:][inds[(2*numTrain):(3*numTrain)]])
def get_polynomials(orbit_to_amount_dictionary):
cycle_roots = [
get_cycle_roots(lengths) for lengths in orbit_to_amount_dictionary
]
new_eigenvalues = [[np.real(x + 1 / x) for x in y] for y in cycle_roots]
new_polynomials = [np.round(polyfromroots(x)) for x in new_eigenvalues]
return new_polynomials
def lagrange_interpolation(a, b, n, f, cheby):
"""
Encuentra el polinomio interpolador de 'f' en [a, b] usando polinomios de lagrange de orden n
@param cheby: True si se usan nodos de chebyshev, de lo contrario equiespaciados
@return (polinomio, (nodos_x, f(nodos_x)))
Los coeficientes del polinomio son: [an,..., a1, a0] que el orden en que np.polyval() recibe los coeficientes
¡Esta función fue realizada por Rafael Nicolás Trozzo, yo simplemente la copie y pegué.!
"""
if cheby:
zj = [
np.cos((2 * j + 1) / (2 * (n + 1)) * np.pi) for j in range(n + 1)
]
x_nodes = [(b + a) / 2 + (b - a) / 2 * z for z in zj]
else:
x_nodes = np.linspace(a, b, n + 1)
y_nodes = [f(x) for x in x_nodes]
# hay n+1 polinomios con n+1 coeficientes
lag_pols = np.zeros((n + 1, n + 1))
for k in range(len(x_nodes)):
# Formamos el polinomio de lagrange k a partir de sus raices
lag_roots = np.delete(x_nodes, k)
lag_pols[k] = np.flip(
poly.polyfromroots(lag_roots)) / np.prod(x_nodes[k] -
lag_roots) * y_nodes[k]
print(lag_pols[k]
) # comentar si no se quieren ver los polinomios de Lagrange
interp_poly = np.sum(lag_pols, axis=0)
return (interp_poly, (x_nodes, y_nodes))
def build_signal(N, dt, comps, wgts):
obsvd = np.zeros(N)
ic = -1
for comp in comps:
ic += 1
r_comp = comp[1]
osc_comp = comp[0]
l_alfa = []
for thr in osc_comp:
r = thr[1]
hz = thr[0]
th = 2 * hz * dt
l_alfa.append(r * (np.cos(np.pi * th) + 1j * np.sin(np.pi * th)))
l_alfa.append(r * (np.cos(np.pi * th) - 1j * np.sin(np.pi * th)))
for r in r_comp:
l_alfa.append(r)
alfa = np.array(l_alfa)
ARcoeff = (-1 * _Npp.polyfromroots(alfa)[::-1][1:]).real
sgnlC, y = createDataAR(N, ARcoeff, 0.01, 0)
obsvd += wgts[ic] * sgnlC
return obsvd / np.std(obsvd)
def runDirAlloc(self, pckl, trials=None): ########### RUN
"""
"""
oo = self # call self oo. takes up less room on line
oo.setname = os.getcwd().split("/")[-1]
oo.Cs = len(oo.freq_lims)
oo.C = oo.Cn + oo.Cs
oo.R = 1
oo.k = 2 * oo.C + oo.R
# x0 -- Gaussian prior
oo.u_x00 = _N.zeros(oo.k)
oo.s2_x00 = _arl.dcyCovMat(oo.k, _N.ones(oo.k), 0.4)
oo.loadDat(trials)
oo.setParams()
oo.us = pckl[0]
oo.q2 = _N.ones(oo.TR) * pckl[1]
oo.F0 = _N.zeros(oo.k)
print len(pckl[2])
for l in xrange(len(pckl[2])):
oo.F0 += (-1 * _Npp.polyfromroots(pckl[2][l])[::-1].real)[1:]
oo.F0 /= len(pckl[2])
oo.aS = pckl[3]
oo.dirichletAllocate()
def test_polyroots(self):
assert_almost_equal(poly.polyroots([1]), [])
assert_almost_equal(poly.polyroots([1, 2]), [-.5])
for i in range(2, 5):
tgt = np.linspace(-1, 1, i)
res = poly.polyroots(poly.polyfromroots(tgt))
assert_almost_equal(trim(res), trim(tgt))
def clean(self, ratio=1000.0):
"""
Eliminates poles and zeros that cancel each other
A pole and a zero are considered equal if their distance
is lower than 1/ratio its magnitude
ratio : Ratio to cancel PZ (default = 1000)
Return a new object
"""
gain = self.gain()
poles = self.poles()
zeros = self.zeros()
# Return if there are no poles or zeros
if len(poles) == 0: return
if len(zeros) == 0: return
outPoles = [] # Empty pole list
for pole in poles:
outZeros = [] # Empty zero list
found = False
for zero in zeros:
if not found:
distance = np.absolute(pole - zero)
threshold = (np.absolute(pole) +
np.absolute(zero)) / (2.0 * ratio)
if distance > threshold:
outZeros.append(zero)
else:
found = True
else:
outZeros.append(zero)
if not found:
outPoles.append(pole)
zeros = outZeros
poles = outPoles
s = linblk()
s.den = P.Polynomial(P.polyfromroots(poles))
s.num = P.Polynomial(P.polyfromroots(zeros))
# Add gain
# curr = s.num.coef[0]/s.den.coef[0]
curr = s.gain()
s.num = s.num * gain / curr
return s
def _pq_completion(P):
"""
Find polynomial Q given P such that the following matrix is unitary.
[[P(a), i Q(a) sqrt(1-a^2)],
i Q*(a) sqrt(1-a^2), P*(a)]]
Args:
P: Polynomial object P.
Returns:
Polynomial object Q giving described unitary matrix.
"""
pcoefs = P.coef
P = Polynomial(pcoefs)
Pc = Polynomial(pcoefs.conj())
roots = (1. - P * Pc).roots()
# catagorize roots
real_roots = np.array([], dtype=np.float64)
imag_roots = np.array([], dtype=np.float64)
cplx_roots = np.array([], dtype=np.complex128)
tol = 1e-6
for root in roots:
if np.abs(np.imag(root)) < tol:
# real roots
real_roots = np.append(real_roots, np.real(root))
elif np.real(root) > -tol and np.imag(root) > -tol:
if np.real(root) < tol:
imag_roots = np.append(imag_roots, np.imag(root))
else:
cplx_roots = np.append(cplx_roots, root)
# remove root r_i = +/- 1
ridx = np.argmin(np.abs(1. - real_roots))
real_roots = np.delete(real_roots, ridx)
ridx = np.argmin(np.abs(-1. - real_roots))
real_roots = np.delete(real_roots, ridx)
# choose real roots in +/- pairs
real_roots = np.sort(real_roots)
real_roots = real_roots[::2]
# include negative conjugate of complex roots
cplx_roots = np.r_[cplx_roots, -cplx_roots]
# construct Q
Q = Polynomial(
polyfromroots(np.r_[real_roots, 1j * imag_roots, cplx_roots]))
Qc = Polynomial(Q.coef.conj())
# normalize
norm = np.sqrt(
(1 - P * Pc).coef[-1] / (Q * Qc * Polynomial([1, 0, -1])).coef[-1])
return Q * norm
def wilkinsonpoly(n, kind=1):
'''
The Wilkinson polynomials.
Ref: https://en.wikipedia.org/wiki/Wilkinson%27s_polynomial
'''
if kind == 1:
roots = np.arange(1, (n + 1))
elif kind == 2:
roots = np.asarray([2**(-i) for i in range(1, (n + 1))])
else:
raise ValueError('Unknown value for kind')
c = poly.polyfromroots(roots)
return c
def test_pathological_roots(r, nroots, delta, rseed=42, tol=1E-5):
rand = np.random.RandomState(rseed)
roots = [root for root in rand.rand(max([int(nroots / 2), 1]))]
for i in range(nroots - len(roots)):
rt = roots[i] + np.sign(0.5 - rand.rand()) * delta
if abs(rt) < 1:
roots.append(rt)
roots = np.sort(roots)
p = pol.polyfromroots(roots)
q = pol.polyfromroots(roots)
pp = PseudoPolynomial(p=p, q=q, r=r)
pproots = np.sort(pp.real_roots())
print(roots, pproots)
proots = pol.polyroots(p)
qroots = pol.polyroots(q)
for root in proots:
dr = min(np.absolute(np.array(roots) - root))
assert (dr < tol)
for root in qroots:
dr = min(np.absolute(np.array(roots) - root))
assert (dr < tol)
for root in pproots:
assert (abs(pp(root)) < tol)
for root in roots:
dr = min(
np.absolute(np.array(pproots) - root) /
max([tol, np.absolute(root)]))
assert (abs(pp(root)) < tol and dr < tol)
def __init__(self, coef, coef_type='monic'):
if len(coef) == 0:
coef = [1.]
elif coef_type == 'monic':
if type(coef) == list:
coef = coef + [1.]
else:
coef = np.concatenate((coef, np.array([1.])))
elif coef_type == 'zeros':
coef = npol.polyfromroots(coef)
elif coef_type == 'normal':
if np.abs(coef[-1] - 1.) > 1e-15:
raise Exception('Coefficients don\'t define a monic polynomial')
else:
raise Exception('Invalid coef_type, should be \'normal\', \'monic\' or \'zeros\'.')
super(monicPolynomial, self).__init__(coef)
def filter_coeffs(p, norm=np.sqrt(2), linphase=False):
''' Calculate the filter coefficients for Daubechies Wavelets
c.f. Strang, Nguyen - "Wavelets and Filters" ch. 5.5
:param p: number of vanishing moments
:param norm: specifies the euclidean norm of the final coefficients
:param linphase: whether to use the "most linear phase" approximation or minimal phase
'''
if p < 1:
raise ValueError("The order of the Wavelets must be at least 1")
if p > 34:
raise ValueError("Sorry, the method does currently not work for orders higher than 34")
if norm <= 0:
raise ValueError("The norm must be larger than 0")
# find roots of the defining polynomial B(y)
B_y = [comb(p + i - 1, i, exact=True) for i in range(p)]
y = poly.polyroots(B_y)
# calculate the roots of C(z) from the roots y via a quadratic formula
roots = [poly.polyroots([1, 4*yi - 2, 1]) for yi in y]
if not linphase:
# take the ones inside the unit circle
z = [root for pair in roots for root in pair if np.abs(root) < 1]
else:
# sort roots according to Kateb & Lemarie-Rieusset (1995)
# note: This does not always yield the 'most linear' set
# but some 'more linear phase'. I might also have misread the paper
imaglargerzero = list(filter(lambda root: np.imag(root[0]) >= 0, roots))
imagsmallerzero = list(filter(lambda root: np.imag(root[0]) < 0, roots))
imaglargerzero.sort(key=lambda x: np.absolute(x[0]))
imagsmallerzero.sort(key=lambda x: np.absolute(x[0]), reverse=True)
sortedroots = imaglargerzero + imagsmallerzero
# take them in some alternating manner
z = []
for i, root in enumerate(sortedroots):
takelarger = ( (i+1)%4 <= 1 )
z.append(root[takelarger*1])
z += [-1]*p
# put together the polynomial C(z) and normalize the coefficients
C_z = np.real(poly.polyfromroots(z)) # imaginary part may be non-zero because of rounding errors
C_z *= norm / sum(C_z)
return C_z[::-1]
def AR2(f, amp, N, dt):
"""
f in Hz
"""
Nyqf = 0.5 / dt
zp = amp * (_N.cos(f * _N.pi / Nyqf) + 1j * _N.sin(f * _N.pi / Nyqf))
zn = amp * (_N.cos(f * _N.pi / Nyqf) - 1j * _N.sin(f * _N.pi / Nyqf))
F = -1 * _Npp.polyfromroots(_N.array([zp, zn]))[::-1].real
xc = _N.zeros(N)
e = 0.1
xc[0] = e * _N.random.randn()
xc[1] = e * _N.random.randn()
for t in range(2, N):
xc[t] = F[1] * xc[t - 1] + F[2] * xc[t - 2] + e * _N.random.randn()
xc /= _N.std(xc)
return xc
def build_signal(N, comps, wgts, innovation_var=0.01, normalize=True):
dt = 0.001
nComps = len(comps)
obsvd = _N.zeros((N, nComps+1))
ic = -1
for comp in comps:
ic += 1
print(comp)
r_comp = comp[1]
osc_comp = comp[0]
l_alfa = []
for thr in osc_comp:
r = thr[1]
hz= thr[0]
th = 2*hz*dt
l_alfa.append(r*(_N.cos(_N.pi*th) + 1j*_N.sin(_N.pi*th)))
l_alfa.append(r*(_N.cos(_N.pi*th) - 1j*_N.sin(_N.pi*th)))
for r in r_comp:
l_alfa.append(r)
alfa = _N.array(l_alfa)
ARcoeff = (-1*_Npp.polyfromroots(alfa)[::-1][1:]).real
sgnlC, y = createDataAR(N, ARcoeff, innovation_var, 0)
obsvd[:, ic] = wgts[ic]*sgnlC
obsvd[:, nComps] += obsvd[:, ic]
if normalize:
for ic in range(nComps):
obsvd[:, ic] /= _N.std(obsvd[:, nComps])
obsvd[:, nComps] /= _N.std(obsvd[:, nComps])
if len(comps) == 1:
return ARcoeff, obsvd
else:
return obsvd
def _roots0(self):
"""
Complex roots of pseudo-poly using `np.polynomial.polyroots` method,
which finds the eigenvalues of the companion matrix of the root-finding
poly.
First finds common roots between `p` and `q` polynomials, then divides
these roots from the `root_finding_poly`.
Returns
-------
roots : list (of floats)
(Complex) roots of the `root_finding_poly`
p : tuple of floats
Coefficients of the root finding polynomial
dp : tuple of floats
Coefficients of the derivative of the root finding polynomial
"""
p = self.root_finding_poly()
dp = remove_zeros(pol.polyder(p))
roots_p = pol.polyroots(self.p)
roots_q = pol.polyroots(self.q)
roots = []
for root in roots_p:
if any([ abs(rq - root) < 1E-5 for rq in roots_q ]):
roots.append(root)
pr = remove_zeros(pol.polyfromroots(roots))
p2, _ = pol.polydiv(p, pol.polymul(pr, pr))
p2 = remove_zeros(p2)
new_roots = list(pol.polyroots(p2))
roots.extend(new_roots)
return roots, p, dp
def polyfromroots(roots) :
from numpy.polynomial.polynomial import polyfromroots
return polyfromroots(roots)
# get parameterized roots
speeds = np.array([1,4,1,4])
num_times = vid_len * frame_ps
param_roots = tf.parameterized_roots1(speeds, num_times)
max_iter = 50
# create image sequence
for i in range(num_times):
# print progress
img_file_name = directory + '/' + imagename + '%05d' % (i+1) + '.png'
print 'Creating frame ' + str(i+1) + ' of ' + str(num_times)
# create polynomial from roots
known_roots = param_roots[i,:]
p = np.flipud(poly.polyfromroots(known_roots))
dp = tf.poly_der(p)
# update param dictionary
params['p'] = p
params['dp'] = dp
# newton's method
roots, con_root, con_num = gn.newton_method(Z, f_val, df_val, params, disp_time=False, known_roots=known_roots, max_iter = max_iter)
# create image in folder
gn.newton_plot(con_root, con_num, colors, save_path=img_file_name, max_shade=max_iter)
# create the movie
ctrlStr = 'ffmpeg -r %d -i %s%%05d.png -c:v libx264 -preset slow -crf %d %s' %(frame_ps, directory + '/' + imagename, quality, filename)
subprocess.call(ctrlStr, shell=True)
def gibbsSamp(
self,
smpls_fn_incl_trls=False): ########################### GIBBSSAMPH
global interrupted
oo = self
signal.signal(signal.SIGINT, signal_handler)
print("****!!!!!!!!!!!!!!!! dohist %s" % str(oo.dohist))
ooTR = oo.TR
ook = oo.k
ooN = oo.N
_kfar.init(oo.N, oo.k, oo.TR)
oo.x00 = _N.array(oo.smpx[:, 2])
oo.V00 = _N.zeros((ooTR, ook, ook))
if oo.dohist:
oo.loghist = _N.zeros(oo.Hbf.shape[0])
else:
print("fixed hist is")
print(oo.loghist)
print("oo.mcmcRunDir %s" % oo.mcmcRunDir)
if oo.mcmcRunDir is None:
oo.mcmcRunDir = ""
elif (len(oo.mcmcRunDir) > 0) and (oo.mcmcRunDir[-1] != "/"):
oo.mcmcRunDir += "/"
ARo = _N.zeros((ooTR, ooN + 1))
kpOws = _N.empty((ooTR, ooN + 1))
lv_f = _N.zeros((ooN + 1, ooN + 1))
lv_u = _N.zeros((ooTR, ooTR))
Bii = _N.zeros((ooN + 1, ooN + 1))
#alpC.reverse()
# F_alfa_rep = alpR + alpC already in right order, no?
Wims = _N.empty((ooTR, ooN + 1, ooN + 1))
Oms = _N.empty((ooTR, ooN + 1))
smWimOm = _N.zeros(ooN + 1)
smWinOn = _N.zeros(ooTR)
bConstPSTH = False
D_f = _N.diag(_N.ones(oo.B.shape[0]) * oo.s2_a) # spline
iD_f = _N.linalg.inv(D_f)
D_u = _N.diag(_N.ones(oo.TR) * oo.s2_u) # This should
iD_u = _N.linalg.inv(D_u)
iD_u_u_u = _N.dot(iD_u, _N.ones(oo.TR) * oo.u_u)
if oo.bpsth:
BDB = _N.dot(oo.B.T, _N.dot(D_f, oo.B))
DB = _N.dot(D_f, oo.B)
BTua = _N.dot(oo.B.T, oo.u_a)
it = -1
oous_rs = oo.us.reshape((ooTR, 1))
#runTO = ooNMC + oo.burn - 1 if (burns is None) else (burns - 1)
runTO = oo.ITERS - 1
oo.allocateSmp(runTO + 1, Bsmpx=oo.doBsmpx)
if cython_arc:
_arcfs.init(ooN + 1 - oo.ignr,
oo.k,
oo.TR,
oo.R,
oo.Cs,
oo.Cn,
aro=_cd.__NF__)
alpR = _N.array(oo.F_alfa_rep[0:oo.R])
alpC = _N.array(oo.F_alfa_rep[oo.R:])
else:
alpR = oo.F_alfa_rep[0:oo.R]
alpC = oo.F_alfa_rep[oo.R:]
BaS = _N.zeros(oo.N + 1) #_N.empty(oo.N+1)
# H shape 100 x 9
Hbf = oo.Hbf
RHS = _N.empty((oo.histknots, 1))
print("----------- histknots %d" % oo.histknots)
cInds = _N.arange(oo.iHistKnotBeginFixed, oo.histknots)
vInds = _N.arange(0, oo.iHistKnotBeginFixed)
#cInds = _N.array([4, 12, 13])
#vInds = _N.array([0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, ])
#vInds = _N.arange(0, oo.iHistKnotBeginFixed)
RHS[cInds, 0] = 0
Msts = []
for m in range(ooTR):
Msts.append(_N.where(oo.y[m] == 1)[0])
HcM = _N.ones((len(vInds), len(vInds)))
HbfExpd = _N.zeros((oo.histknots, ooTR, oo.N + 1))
#HbfExpd = _N.zeros((oo.histknots, ooTR, oo.Hbf.shape[0]))
# HbfExpd is 11 x M x 1200
# find the mean. For the HISTORY TERM
for i in range(oo.histknots):
for m in range(oo.TR):
sts = Msts[m]
HbfExpd[i, m, 0:sts[0]] = 0
for iss in range(len(sts) - 1):
t0 = sts[iss]
t1 = sts[iss + 1]
#HbfExpd[i, m, t0+1:t1+1] = Hbf[1:t1-t0+1, i]#Hbf[0:t1-t0, i]
HbfExpd[i, m, t0 + 1:t1 + 1] = Hbf[0:t1 - t0, i]
HbfExpd[i, m, sts[-1] + 1:] = 0
_N.dot(oo.B.T, oo.aS, out=BaS)
if oo.hS is None:
oo.hS = _N.zeros(oo.histknots)
if oo.dohist:
_N.dot(Hbf, oo.hS, out=oo.loghist)
oo.stitch_Hist(ARo, oo.loghist, Msts)
## ORDER OF SAMPLING
## f_xx, f_V
## DA: PG, kpOws
## history, build ARo
## psth
## offset
## DA: latent state
## AR coefficients
## q2
K = _N.empty((oo.TR, oo.N + 1, oo.k)) # kalman gain
iterBLOCKS = oo.ITERS // oo.peek
smpx_C_cont = _N.empty((oo.TR, oo.N + 1, oo.k)) # need C contiguous
# oo.smpx[:, 1+oo.ignr:, 0:ook], oo.smpx[:, oo.ignr:, 0:ook-1]
smpx_contiguous1 = _N.zeros((oo.TR, oo.N + 2, oo.k))
smpx_contiguous2 = _N.zeros((oo.TR, (oo.N + 1) + 2, oo.k - 1))
if (cython_inv_v == 3) or (cython_inv_v == 5):
oo.if_V = _N.array(oo.f_V)
oo.chol_L_fV = _N.array(oo.f_V)
###### Gibbs sampling procedure
ttts = _N.zeros((oo.ITERS, 9))
for itrB in range(iterBLOCKS):
it = itrB * oo.peek
if it > 0:
# 0.5*oo.fs because (dt*2) -> 1 corresponds to Fs/2
print("---------it: %(it)d mnStd %(mnstd).3f" % {
"it": itrB * oo.peek,
"mnstd": oo.mnStds[it - 1]
})
if not oo.noAR:
print(prt)
mnttt = _N.mean(ttts[0:it - 1], axis=0)
for ti in range(9):
print("t%(2)d-t%(1)d %(ttt).4f" % {
"1": ti + 1,
"2": ti + 2,
"ttt": mnttt[ti]
})
if interrupted:
break
for it in range(itrB * oo.peek, (itrB + 1) * oo.peek):
ttt1 = _tm.time()
itstore = it // oo.BsmpxSkp
# generate latent AR state
oo.f_x[:, 0] = oo.x00
if it == 0:
for m in range(ooTR):
oo.f_V[m, 0] = oo.s2_x00
else:
oo.f_V[:, 0] = _N.mean(oo.f_V[:, 1:], axis=1)
### PG latent variable sample
ttt2 = _tm.time()
for m in range(ooTR):
lw.rpg_devroye(oo.rn,
oo.smpx[m, 2:, 0] + oo.us[m] + BaS +
ARo[m] + oo.knownSig[m],
out=oo.ws[m]) ###### devryoe
ttt3 = _tm.time()
if ooTR == 1:
oo.ws = oo.ws.reshape(1, ooN + 1)
_N.divide(oo.kp, oo.ws, out=kpOws)
if oo.dohist:
O = kpOws - oo.smpx[..., 2:, 0] - oo.us.reshape(
(ooTR, 1)) - BaS - oo.knownSig
#print(oo.ws)
# for i in vInds:
# #print("i %d" % i)
# #print(_N.sum(HbfExpd[i]))
# for j in vInds:
# #print("j %d" % j)
# #print(_N.sum(HbfExpd[j]))
# HcM[i-iOf, j-iOf] = _N.sum(oo.ws*HbfExpd[i]*HbfExpd[j])
# RHS[i, 0] = _N.sum(oo.ws*HbfExpd[i]*O)
# for cj in cInds:
# RHS[i, 0] -= _N.sum(oo.ws*HbfExpd[i]*HbfExpd[cj])*RHS[cj, 0]
for ii in range(len(vInds)):
#print("i %d" % i)
#print(_N.sum(HbfExpd[i]))
i = vInds[ii]
for jj in range(len(vInds)):
j = vInds[jj]
#print("j %d" % j)
#print(_N.sum(HbfExpd[j]))
HcM[ii,
jj] = _N.sum(oo.ws * HbfExpd[i] * HbfExpd[j])
RHS[ii, 0] = _N.sum(oo.ws * HbfExpd[i] * O)
for cj in cInds:
RHS[ii, 0] -= _N.sum(
oo.ws * HbfExpd[i] * HbfExpd[cj]) * RHS[cj, 0]
# print("HbfExpd..............................")
# for i in range(oo.histknots):
# print(_N.sum(HbfExpd[i]))
# print("HcM..................................")
# print(HcM)
# print("RHS..................................")
# print(RHS[vInds])
vm = _N.linalg.solve(HcM, RHS[vInds])
Cov = _N.linalg.inv(HcM)
#print vm
#print(Cov)
#print(vm[:, 0])
cfs = _N.random.multivariate_normal(vm[:, 0], Cov, size=1)
RHS[vInds, 0] = cfs[0]
oo.smp_hS[it] = RHS[:, 0]
#RHS[2:6, 0] = vm[:, 0]
#vv = _N.dot(Hbf, RHS)
#print vv.shape
#print oo.loghist.shape
_N.dot(Hbf, RHS[:, 0], out=oo.loghist)
oo.smp_hist[it] = oo.loghist
oo.stitch_Hist(ARo, oo.loghist, Msts)
else:
oo.smp_hist[it] = oo.loghist
oo.stitch_Hist(ARo, oo.loghist, Msts)
# Now that we have PG variables, construct Gaussian timeseries
# ws(it+1) using u(it), F0(it), smpx(it)
# cov matrix, prior of aS
# oo.gau_obs = kpOws - BaS - ARo - oous_rs - oo.knownSig
# oo.gau_var =1 / oo.ws # time dependent noise
ttt4 = _tm.time()
if oo.bpsth:
Oms = kpOws - oo.smpx[..., 2:,
0] - ARo - oous_rs - oo.knownSig
_N.einsum("mn,mn->n", oo.ws, Oms, out=smWimOm) # sum over
ilv_f = _N.diag(_N.sum(oo.ws, axis=0))
# diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
_N.fill_diagonal(lv_f, 1. / _N.diagonal(ilv_f))
lm_f = _N.dot(lv_f, smWimOm) # nondiag of 1./Bi are inf
# now sample
iVAR = _N.dot(oo.B, _N.dot(ilv_f, oo.B.T)) + iD_f
ttt4a = _tm.time()
VAR = _N.linalg.inv(iVAR) # knots x knots
ttt4b = _tm.time()
#iBDBW = _N.linalg.inv(BDB + lv_f) # BDB not diag
#Mn = oo.u_a + _N.dot(DB, _N.dot(iBDBW, lm_f - BTua))
# BDB + lv_f (N+1 x N+1)
# lm_f - BTua (N+1)
Mn = oo.u_a + _N.dot(
DB, _N.linalg.solve(BDB + lv_f, lm_f - BTua))
#t4c = _tm.time()
oo.aS = _N.random.multivariate_normal(Mn, VAR,
size=1)[0, :]
oo.smp_aS[it] = oo.aS
_N.dot(oo.B.T, oo.aS, out=BaS)
ttt5 = _tm.time()
######## per trial offset sample burns==None, only psth fit
Ons = kpOws - oo.smpx[..., 2:, 0] - ARo - BaS - oo.knownSig
# solve for the mean of the distribution
if not oo.bpsth: # if not doing PSTH, don't constrain offset, as there are no confounds controlling offset
_N.einsum("mn,mn->m", oo.ws, Ons,
out=smWinOn) # sum over trials
ilv_u = _N.diag(_N.sum(oo.ws, axis=1)) # var of LL
# diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
_N.fill_diagonal(lv_u, 1. / _N.diagonal(ilv_u))
lm_u = _N.dot(
lv_u, smWinOn) # nondiag of 1./Bi are inf, mean LL
# now sample
iVAR = ilv_u + iD_u
VAR = _N.linalg.inv(iVAR) #
Mn = _N.dot(VAR, _N.dot(ilv_u, lm_u) + iD_u_u_u)
oo.us[:] = _N.random.multivariate_normal(Mn, VAR,
size=1)[0, :]
if not oo.bIndOffset:
oo.us[:] = _N.mean(oo.us)
oo.smp_u[it] = oo.us
else:
H = _N.ones((oo.TR - 1, oo.TR - 1)) * _N.sum(oo.ws[0])
uRHS = _N.empty(oo.TR - 1)
for dd in range(1, oo.TR):
H[dd - 1, dd - 1] += _N.sum(oo.ws[dd])
uRHS[dd - 1] = _N.sum(oo.ws[dd] * Ons[dd] -
oo.ws[0] * Ons[0])
MM = _N.linalg.solve(H, uRHS)
Cov = _N.linalg.inv(H)
oo.us[1:] = _N.random.multivariate_normal(MM, Cov, size=1)
oo.us[0] = -_N.sum(oo.us[1:])
if not oo.bIndOffset:
oo.us[:] = _N.mean(oo.us)
oo.smp_u[it] = oo.us
# Ons = kpOws - ARo
# _N.einsum("mn,mn->m", oo.ws, Ons, out=smWinOn) # sum over trials
# ilv_u = _N.diag(_N.sum(oo.ws, axis=1)) # var of LL
# # diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
# _N.fill_diagonal(lv_u, 1./_N.diagonal(ilv_u))
# lm_u = _N.dot(lv_u, smWinOn) # nondiag of 1./Bi are inf, mean LL
# # now sample
# iVAR = ilv_u + iD_u
# VAR = _N.linalg.inv(iVAR) #
# Mn = _N.dot(VAR, _N.dot(ilv_u, lm_u) + iD_u_u_u)
# oo.us[:] = _N.random.multivariate_normal(Mn, VAR, size=1)[0, :]
# if not oo.bIndOffset:
# oo.us[:] = _N.mean(oo.us)
# oo.smp_u[:, it] = oo.us
ttt6 = _tm.time()
if not oo.noAR:
# _d.F, _d.N, _d.ks,
#_kfar.armdl_FFBS_1itrMP(oo.gau_obs, oo.gau_var, oo.Fs, _N.linalg.inv(oo.Fs), oo.q2, oo.Ns, oo.ks, oo.f_x, oo.f_V, oo.p_x, oo.p_V, oo.smpx, K)
oo.gau_obs = kpOws - BaS - ARo - oous_rs - oo.knownSig
oo.gau_var = 1 / oo.ws # time dependent noise
#print(oo.Fs)
#print(_N.linalg.inv(oo.Fs))
if (cython_inv_v == 2):
_kfar.armdl_FFBS_1itrMP(oo.gau_obs, oo.gau_var, oo.Fs,
_N.linalg.inv(oo.Fs), oo.q2,
oo.Ns, oo.ks, oo.f_x, oo.f_V,
oo.p_x, oo.p_V, smpx_C_cont, K)
else:
_kfar.armdl_FFBS_1itrMP(oo.gau_obs, oo.gau_var, oo.Fs,
_N.linalg.inv(oo.Fs), oo.q2,
oo.Ns, oo.ks, oo.f_x, oo.f_V,
oo.chol_L_fV, oo.if_V, oo.p_x,
oo.p_V, smpx_C_cont, K)
oo.smpx[:, 2:] = smpx_C_cont
oo.smpx[:, 1, 0:ook - 1] = oo.smpx[:, 2, 1:]
oo.smpx[:, 0, 0:ook - 2] = oo.smpx[:, 2, 2:]
if oo.doBsmpx and (it % oo.BsmpxSkp == 0):
oo.Bsmpx[it // oo.BsmpxSkp, :, 2:] = oo.smpx[:, 2:, 0]
#oo.Bsmpx[it // oo.BsmpxSkp, :, 2:] = oo.smpx[:, 2:, 0]
stds = _N.std(oo.smpx[:, 2 + oo.ignr:, 0], axis=1)
oo.mnStds[it] = _N.mean(stds, axis=0)
ttt7 = _tm.time()
#print("..................................")
#print(alpR)
#print(alpC)
#print(alpR)
#print(alpC)
# print(oo.smpx[0, 0:20, 0])
# print(oo.q2)
if cython_arc:
_N.copyto(smpx_contiguous1, oo.smpx[:, 1 + oo.ignr:])
_N.copyto(smpx_contiguous2, oo.smpx[:, oo.ignr:,
0:ook - 1])
#ARcfSmpl(int N, int k, int TR, AR2lims_nmpy, smpxU, smpxW, double[::1] q2, int R, int Cs, int Cn, complex[::1] valpR, complex[::1] valpC, double sig_ph0L, double sig_ph0H, double prR_s2)
oo.uts[itstore], oo.wts[itstore] = _arcfs.ARcfSmpl(
ooN + 1 - oo.ignr, ook, oo.TR, oo.AR2lims,
smpx_contiguous1, smpx_contiguous2, oo.q2, oo.R,
oo.Cs, oo.Cn, alpR, alpC, oo.sig_ph0L, oo.sig_ph0H,
0.2 * 0.2)
else:
oo.uts[itstore], oo.wts[itstore] = _arcfs.ARcfSmpl(
ooN + 1 - oo.ignr,
ook,
oo.AR2lims,
oo.smpx[:, 1 + oo.ignr:, 0:ook],
oo.smpx[:, oo.ignr:, 0:ook - 1],
oo.q2,
oo.R,
oo.Cs,
oo.Cn,
alpR,
alpC,
oo.TR,
aro=oo.ARord,
sig_ph0L=oo.sig_ph0L,
sig_ph0H=oo.sig_ph0H)
#oo.F_alfa_rep = alpR + alpC # new constructed
oo.F_alfa_rep[0:oo.R] = alpR
oo.F_alfa_rep[oo.R:] = alpC
prt, rank, f, amp = ampAngRep(oo.F_alfa_rep,
oo.dt,
f_order=True)
#print(f)
#print(amp)
ttt8 = _tm.time()
#print prt
#ut, wt = FilteredTimeseries(ooN+1, ook, oo.smpx[:, 1:, 0:ook], oo.smpx[:, :, 0:ook-1], oo.q2, oo.R, oo.Cs, oo.Cn, alpR, alpC, oo.TR)
#ranks[it] = rank
oo.allalfas[it] = oo.F_alfa_rep
for m in range(ooTR):
#oo.wts[m, it, :, :] = wt[m, :, :, 0]
#oo.uts[m, it, :, :] = ut[m, :, :, 0]
if not oo.bFixF:
oo.amps[it, :] = amp
oo.fs[it, :] = f
ttt9 = _tm.time()
oo.F0 = (-1 *
_Npp.polyfromroots(oo.F_alfa_rep)[::-1].real)[1:]
for tr in range(oo.TR):
oo.Fs[tr, 0] = oo.F0[:]
# sample u WE USED TO Do this after smpx
# u(it+1) using ws(it+1), F0(it), smpx(it+1), ws(it+1)
oo.a2 = oo.a_q2 + 0.5 * (ooTR * ooN + 2) # N + 1 - 1
#oo.a2 = 0.5*(ooTR*(ooN-oo.ignr) + 2) # N + 1 - 1
BB2 = oo.B_q2
#BB2 = 0
for m in range(ooTR):
# set x00
oo.x00[m] = oo.smpx[m, 2] * 0.1
##################### sample q2
rsd_stp = oo.smpx[m, 3 + oo.ignr:, 0] - _N.dot(
oo.smpx[m, 2 + oo.ignr:-1], oo.F0).T
#oo.rsds[it, m] = _N.dot(rsd_stp, rsd_stp.T)
BB2 += 0.5 * _N.dot(rsd_stp, rsd_stp.T)
oo.q2[:] = _ss.invgamma.rvs(oo.a2, scale=BB2)
oo.smp_q2[it] = oo.q2
ttt10 = _tm.time()
else:
ttt7 = ttt8 = ttt9 = ttt10 = ttt6
ttt10 = _tm.time()
ttts[it, 0] = ttt2 - ttt1
ttts[it, 1] = ttt3 - ttt2
ttts[it, 2] = ttt4 - ttt3
ttts[it, 3] = ttt5 - ttt4
ttts[it, 4] = ttt6 - ttt5
ttts[it, 5] = ttt7 - ttt6
ttts[it, 6] = ttt8 - ttt7
ttts[it, 7] = ttt9 - ttt8
ttts[it, 8] = ttt10 - ttt9
oo.last_iter = it
if it > oo.minITERS:
smps = _N.empty((3, it + 1))
smps[0, :it + 1] = oo.amps[:it + 1, 0]
smps[1, :it + 1] = oo.fs[:it + 1, 0]
smps[2, :it + 1] = oo.mnStds[:it + 1]
#frms = _mg.stationary_from_Z_bckwd(smps, blksz=oo.peek)
if _mg.stationary_test(oo.amps[:it + 1, 0],
oo.fs[:it + 1, 0],
oo.mnStds[:it + 1],
it + 1,
blocksize=oo.mg_blocksize,
points=oo.mg_points):
break
"""
fig = _plt.figure(figsize=(8, 8))
fig.add_subplot(3, 1, 1)
_plt.plot(range(1, it), oo.amps[1:it, 0], color="grey", lw=1.5)
_plt.plot(range(0, it), oo.amps[0:it, 0], color="black", lw=3)
_plt.ylabel("amp")
fig.add_subplot(3, 1, 2)
_plt.plot(range(1, it), oo.fs[1:it, 0]/(2*oo.dt), color="grey", lw=1.5)
_plt.plot(range(0, it), oo.fs[0:it, 0]/(2*oo.dt), color="black", lw=3)
_plt.ylabel("f")
fig.add_subplot(3, 1, 3)
_plt.plot(range(1, it), oo.mnStds[1:it], color="grey", lw=1.5)
_plt.plot(range(0, it), oo.mnStds[0:it], color="black", lw=3)
_plt.ylabel("amp")
_plt.xlabel("iter")
_plt.savefig("%(dir)stmp-fsamps%(it)d" % {"dir" : oo.mcmcRunDir, "it" : it+1})
fig.subplots_adjust(left=0.15, bottom=0.15, right=0.95, top=0.95)
_plt.close()
"""
#if it - frms > oo.stationaryDuration:
# break
oo.getComponents()
oo.dump_smps(0,
toiter=(it + 1),
dir=oo.mcmcRunDir,
smpls_fn_incl_trls=smpls_fn_incl_trls)
def gibbsSamp(self, N, ITER, obsvd, peek=50, skp=50):
"""
peek
"""
oo = self
oo.TR = 1
sig_ph0L = -1
sig_ph0H = 0 #
oo.obsvd = obsvd
oo.skp = skp
radians = buildLims(0, oo.freq_lims, nzLimL=1., Fs=oo.Fs)
AR2lims = 2*_N.cos(radians)
F_alfa_rep = initF(oo.R, oo.C, 0).tolist() # init F_alfa_rep
if ram:
alpR = _N.array(F_alfa_rep[0:oo.R], dtype=_N.complex)
alpC = _N.array(F_alfa_rep[oo.R:], dtype=_N.complex)
alpC_tmp = _N.array(F_alfa_rep[oo.R:], dtype=_N.complex)
else:
alpR = F_alfa_rep[0:oo.R]
alpC = F_alfa_rep[oo.R:]
alpC_tmp = list(F_alfa_rep[oo.R:])
q2 = _N.array([0.01])
oo.smpx = _N.empty((oo.TR, N+2, oo.k))
oo.fs = _N.empty((ITER//skp, oo.C))
oo.rs = _N.empty((ITER//skp, oo.R))
oo.amps = _N.empty((ITER//skp, oo.C))
oo.q2s = _N.empty(ITER//skp)
oo.uts = _N.empty((ITER//skp, oo.TR, oo.R, N+1, 1))
oo.wts = _N.empty((ITER//skp, oo.TR, oo.C, N+2, 1))
# oo.smpx[:, 1+oo.ignr:, 0:ook], oo.smpx[:, oo.ignr:, 0:ook-1]
if ram:
_arcfs.init(N, oo.k, 1, oo.R, oo.C, 0, aro=_cd.__NF__)
smpx_contiguous1 = _N.zeros((oo.TR, N + 1, oo.k))
smpx_contiguous2 = _N.zeros((oo.TR, N + 2, oo.k-1))
for n in range(N):
oo.smpx[0, n+2] = oo.obsvd[0, n:n+oo.k][::-1]
for m in range(oo.TR):
oo.smpx[0, 1, 0:oo.k-1] = oo.smpx[0, 2, 1:]
oo.smpx[0, 0, 0:oo.k-2] = oo.smpx[0, 2, 2:]
if ram:
_N.copyto(smpx_contiguous1,
oo.smpx[:, 1:])
_N.copyto(smpx_contiguous2,
oo.smpx[:, 0:, 0:oo.k-1])
oo.allalfas = _N.empty((ITER, oo.k), dtype=_N.complex)
for it in range(ITER):
itstore = it // skp
if it % peek == 0:
if it > 0:
print("%d -----------------" % it)
print(prt)
if ram:
oo.uts[itstore], oo.wts[itstore] = _arcfs.ARcfSmpl(N+1, oo.k, oo.TR, AR2lims, smpx_contiguous1, smpx_contiguous2, q2, oo.R, 0, oo.C, alpR, alpC, sig_ph0L, sig_ph0H, 0.2*0.2)
else:
oo.uts[itstore], oo.wts[itstore] = _arcfs.ARcfSmpl(N, oo.k, AR2lims, oo.smpx[:, 1:, 0:oo.k], oo.smpx[:, :, 0:oo.k-1], q2, oo.R, oo.C, 0, alpR, alpC, oo.TR, aro=ARord, sig_ph0L=sig_ph0L, sig_ph0H=sig_ph0H)
F_alfa_rep[0:oo.R] = alpR
F_alfa_rep[oo.R:] = alpC
oo.allalfas[it] = F_alfa_rep
#F_alfa_rep = alpR + alpC # new constructed
prt, rank, f, amp = ampAngRep(F_alfa_rep, oo.dt, f_order=True)
# reorder
if oo.freq_order:
# coh = _N.where(amp > 0.95)[0]
# slow= _N.where(f[coh] < f_thr)[0]
# # first, rearrange
for i in range(oo.C):
alpC_tmp[2*i] = alpC[rank[i]*2]
alpC_tmp[2*i+1] = alpC[rank[i]*2+1]
for i in range(oo.C):
alpC[2*i] = alpC_tmp[2*i]
alpC[2*i+1] = alpC_tmp[2*i+1]
oo.amps[itstore, :] = amp[rank]
oo.fs[itstore, :] = 0.5*(f[rank]/oo.dt)
else:
oo.amps[itstore, :] = amp
oo.fs[itstore, :] = 0.5*(f/oo.dt)
oo.rs[itstore] = alpR
F0 = (-1*_Npp.polyfromroots(F_alfa_rep)[::-1].real)[1:]
a2 = oo.a_q2 + 0.5*(oo.TR*N + 2) # N + 1 - 1
BB2 = oo.B_q2
for m in range(oo.TR):
# set x00
rsd_stp = oo.smpx[m, 3:, 0] - _N.dot(oo.smpx[m, 2:-1], F0).T
BB2 += 0.5 * _N.dot(rsd_stp, rsd_stp.T)
q2[:] = _ss.invgamma.rvs(a2, scale=BB2)
oo.q2s[itstore] = q2[0]
it0=0
it1=ITER
it0 = it0 // skp
it1 = it1 // skp
def polyfromroots(roots):
from numpy.polynomial.polynomial import polyfromroots
return polyfromroots(roots)
def find_zeros_and_poles_(self,
eps_reg=1e-15,
eps_stop=1e-10,
P_estimate=0,
pprint=False):
"""
Find the zeros and poles of a complex function (C->C) inside a closed curve.
input:
-fun: callable, the function of which the poles have to be found
-dfun: callable, the derivative of the function
-contours: list of callables, the contours (R->C) that constitute
a closed curve in the complex plane
-dcontours: list of callables, the derivatives (R->C) of the
respective contours
-t_params: list of arrays, the parametrizations of the contours
!!! Hard to get stopping right !!!
"""
# total multiplicity of zeros (number of zeros * order)
pol_unity = monicPolynomial([])
p_unity = pol_unity.f_polynomial()
s0 = int(round(self.inner_prod(p_unity, p_unity).real))
N = s0 + 2 * P_estimate
if pprint: print('N =', N)
# list of FOPs
phis = []
pols = []
phis.append(p_unity)
pols.append(pol_unity) # phi_0
# if s0 is zero
if s0 == 0:
n = 0
# arithmetic mean of nodes is zero
mu = 0.
pol = monicPolynomial([0.])
phis.append(pol.f_polynomial())
pols.append(pol) # phi_1
zeros = np.array([])
r = 0
t = 1
else:
# compute arithmetic mean of nodes
p_aux = monicPolynomial([0.]).f_polynomial()
mu = self.inner_prod(p_unity, p_aux) / N
if pprint: print('mu =', mu)
# append first polynomial
pol = monicPolynomial([-mu])
phis.append(pol.f_polynomial())
pols.append(pol) # phi_1
# if the algorithm quits after the first zero, it is mu
zeros = np.array([mu])
n = 1
# initialization
r = 1
t = 0
while r + t < N:
if pprint: print('1.')
# naive criterion to check if phi_r+t+1 is regular
prod_aux, maxpsum = self.inner_prod(phis[-1],
phis[-1],
compute_maxpsum=True)
# compute eigenvalues of the next pencil
G, G1 = self.generalized_hankel_matrices(phis, pols)
eigv = la.eigvals(G1, G)
# check if these eigenvalues lie within the contour
if self.points_within_contour(eigv + mu):
# if np.abs(prod_aux)/maxpsum > eps_reg:
if pprint: print('1.1')
# compute next FOP in the regular way
pol = monicPolynomial(eigv, coef_type='zeros')
phis.append(pol.f_polynomial())
pols.append(pol)
r += t + 1
t = 0
allsmall = True
tau = 0
while allsmall and (r + tau) < N:
if pprint: print('1.1.1')
# if all further inner porducts are zero
taupol = npol.polyfromroots([mu for _ in range(tau)])
tauphi = monicPolynomial(
npol.polymul(taupol, pols[-1].coef),
coef_type='normal').f_polynomial()
ip, maxpsum = self.inner_prod(tauphi,
phis[r],
compute_maxpsum=True)
tau += 1
if np.abs(ip) / maxpsum > eps_stop:
allsmall = False
if allsmall:
if pprint: print('1.1.2: STOP')
n = r
zeros = eigv + mu
t = N # STOP
else:
if pprint: print('1.2')
c = npol.polyfromroots([mu])
pol = monicPolynomial(npol.polymul(c, pols[-1].coef),
coef_type='normal')
pols.append(pol)
phis.append(pol.f_polynomial())
t += 1
# check multiplicities
# constuct vandermonde system
A = np.vander(zeros).T[::-1, :]
b = np.array(
[self.inner_prod(p_unity, lambda x, k=k: x**k) for k in range(n)])
# solve the Vandermonde system
nu = la.solve(A, b)
nu = np.round(nu).real.astype(int)
# for printing result
if pprint:
print('>>> Result of computation of zeros <<<')
print('number of zeros = ', n - len(np.where(nu == 0)[0]))
for i, zero in enumerate(zeros):
print('zero #' + str(i + 1) + ' = ' + str(zero) +
' (multiplicity = ' + str(nu[i]) + ')')
print('')
# eliminate spurious zeros (the ones with zero multiplicity)
inds = np.where(nu > 0)[0]
return zeros[inds], n, nu[inds]
def find_zeros(self, pprint=False):
"""
Find the zeros and poles of a complex function (C->C) inside a closed curve.
input:
"""
# total multiplicity of zeros (number of zeros * order)
pol_unity = monicPolynomial([])
p_unity = pol_unity.f_polynomial()
residue = self.inner_prod(p_unity, p_unity)
N = int(round(residue.real))
accuracy = np.abs(N - residue)
if pprint: print('N =', N, ' (accuracy =', accuracy, ')')
# if N is zero
if N == 0:
n = 0
zeros = np.array([])
else:
# list of FOPs
phis = []
pols = []
phis.append(p_unity)
pols.append(pol_unity) # phi_0
# compute arithmetic mean of nodes
p_aux = monicPolynomial([0.]).f_polynomial()
mu = self.inner_prod(p_unity, p_aux) / N
if pprint: print('mu =', mu)
# append first polynomial
pol = monicPolynomial([-mu])
phis.append(pol.f_polynomial())
pols.append(pol) # phi_1
# if the algorithm quits after the first zero, it is mu
zeros = np.array([mu])
n = 1
# initialization
r = 1
t = 0
while r + t < N:
if pprint: print(str(r + t))
# naive criterion to check if phi_r+t+1 is regular
prod_aux, maxpsum = self.inner_prod(phis[-1],
phis[-1],
compute_maxpsum=True)
# compute eigenvalues of the next pencil
G, G1 = self.generalized_hankel_matrices(phis, pols)
eigv = la.eigvals(G1, G)
# print eigv
# check if these eigenvalues lie within the contour
if self.points_within_contour(eigv + mu):
# if np.abs(prod_aux)/maxpsum > eps_reg:
if pprint: print(str(r + t) + '.1')
# compute next FOP in the regular way
pol = monicPolynomial(eigv, coef_type='zeros')
phis.append(pol.f_polynomial())
pols.append(pol)
r += t + 1
t = 0
n = r
zeros = eigv + mu
else:
if pprint: print(str(r + t) + '.2')
c = npol.polyfromroots([mu])
pol = monicPolynomial(npol.polymul(c, pols[-1].coef),
coef_type='normal')
pols.append(pol)
phis.append(pol.f_polynomial())
t += 1
# check multiplicities
# constuct vandermonde system
if len(zeros) > 0:
A = np.vander(zeros).T[::-1, :]
b = np.array([
self.inner_prod(p_unity, lambda x, k=k: x**k) for k in range(n)
])
# solve the Vandermonde system
nu = la.solve(A, b)
nu = np.round(nu).real.astype(int)
sane = (np.sum(nu) == N)
else:
nu = np.array([])
sane = True
# for printing result
if pprint:
print('>>> Result of computation of zeros <<<')
print('number of zeros = ', n - len(np.where(nu == 0)[0]))
pstring = 'yes!' if sane == 1 else 'no!'
print('sane? ' + pstring)
for i, zero in enumerate(zeros):
print('zero #' + str(i + 1) + ' = ' + str(zero) +
' (multiplicity = ' + str(nu[i]) + ')')
print('')
# eliminate spurious zeros (the ones with zero multiplicity)
inds_ = np.argsort(zeros.real)
# inds = np.where(nu[inds_] > 0)[0]
if self.use_known_zeros:
self.global_zeros = np.concatenate(
(self.global_zeros, zeros[inds_][inds]))
self.global_zmultiplicities = np.concatenate(
(self.global_zmultiplicities, nu[inds_][inds]))
iglob = np.argsort(self.global_zeros.real)
self.global_zeros = self.global_zeros[iglob]
self.global_zmultiplicities = self.global_zmultiplicities[iglob]
return zeros[inds_], (n - len(np.where(nu == 0)[0]), nu[inds_], sane)
def gibbsSamp(self): ########################### GIBBSSAMPH
oo = self
print("****!!!!!!!!!!!!!!!! dohist %s" % str(oo.dohist))
ooTR = oo.TR
ook = oo.k
ooN = oo.N
_kfar.init(oo.N, oo.k, oo.TR)
oo.x00 = _N.array(oo.smpx[:, 2])
oo.V00 = _N.zeros((ooTR, ook, ook))
if oo.dohist:
oo.loghist = _N.zeros(oo.N + 1)
else:
print("fixed hist is")
print(oo.loghist)
print("oo.mcmcRunDir %s" % oo.mcmcRunDir)
if oo.mcmcRunDir is None:
oo.mcmcRunDir = ""
elif (len(oo.mcmcRunDir) > 0) and (oo.mcmcRunDir[-1] != "/"):
oo.mcmcRunDir += "/"
ARo = _N.zeros((ooTR, ooN + 1))
kpOws = _N.empty((ooTR, ooN + 1))
lv_f = _N.zeros((ooN + 1, ooN + 1))
lv_u = _N.zeros((ooTR, ooTR))
Bii = _N.zeros((ooN + 1, ooN + 1))
#alpC.reverse()
# F_alfa_rep = alpR + alpC already in right order, no?
Wims = _N.empty((ooTR, ooN + 1, ooN + 1))
Oms = _N.empty((ooTR, ooN + 1))
smWimOm = _N.zeros(ooN + 1)
smWinOn = _N.zeros(ooTR)
bConstPSTH = False
D_f = _N.diag(_N.ones(oo.B.shape[0]) * oo.s2_a) # spline
iD_f = _N.linalg.inv(D_f)
D_u = _N.diag(_N.ones(oo.TR) * oo.s2_u) # This should
iD_u = _N.linalg.inv(D_u)
iD_u_u_u = _N.dot(iD_u, _N.ones(oo.TR) * oo.u_u)
if oo.bpsth:
BDB = _N.dot(oo.B.T, _N.dot(D_f, oo.B))
DB = _N.dot(D_f, oo.B)
BTua = _N.dot(oo.B.T, oo.u_a)
it = -1
oous_rs = oo.us.reshape((ooTR, 1))
#runTO = ooNMC + oo.burn - 1 if (burns is None) else (burns - 1)
runTO = oo.ITERS - 1
oo.allocateSmp(runTO + 1, Bsmpx=oo.doBsmpx)
alpR = oo.F_alfa_rep[0:oo.R]
alpC = oo.F_alfa_rep[oo.R:]
BaS = _N.zeros(oo.N + 1) #_N.empty(oo.N+1)
# H shape 100 x 9
Hbf = oo.Hbf
RHS = _N.empty((oo.histknots, 1))
print("----------- histknots %d" % oo.histknots)
if oo.h0_1 > 1: # no spikes in first few time bins
print("!!!!!!! hist scenario 1")
#cInds = _N.array([0, 1, 5, 6, 7, 8, 9, 10])
#cInds = _N.array([0, 4, 5, 6, 7, 8, 9])
cInds = _N.array([0, 5, 6, 7, 8, 9])
#vInds = _N.array([2, 3, 4])
vInds = _N.array([1, 2, 3, 4])
RHS[cInds, 0] = 0
RHS[0, 0] = -5
elif oo.hist_max_at_0: # no refractory period
print("!!!!!!! hist scenario 2")
#cInds = _N.array([5, 6, 7, 8, 9, 10])
cInds = _N.array([
0,
4,
5,
6,
7,
8,
])
vInds = _N.array([1, 2, 3])
#vInds = _N.array([0, 1, 2, 3, 4])
RHS[cInds, 0] = 0
RHS[0, 0] = 0
else:
print("!!!!!!! hist scenario 3")
#cInds = _N.array([5, 6, 7, 8, 9, 10])
cInds = _N.array([
4,
5,
6,
7,
8,
9,
])
vInds = _N.array([
0,
1,
2,
3,
])
#vInds = _N.array([0, 1, 2, 3, 4])
RHS[cInds, 0] = 0
Msts = []
for m in range(ooTR):
Msts.append(_N.where(oo.y[m] == 1)[0])
HcM = _N.empty((len(vInds), len(vInds)))
HbfExpd = _N.zeros((oo.histknots, ooTR, oo.N + 1))
# HbfExpd is 11 x M x 1200
# find the mean. For the HISTORY TERM
for i in range(oo.histknots):
for m in range(oo.TR):
sts = Msts[m]
HbfExpd[i, m, 0:sts[0]] = 0
for iss in range(len(sts) - 1):
t0 = sts[iss]
t1 = sts[iss + 1]
#HbfExpd[i, m, t0+1:t1+1] = Hbf[1:t1-t0+1, i]#Hbf[0:t1-t0, i]
HbfExpd[i, m, t0 + 1:t1 + 1] = Hbf[0:t1 - t0, i]
HbfExpd[i, m, sts[-1] + 1:] = 0
_N.dot(oo.B.T, oo.aS, out=BaS)
if oo.hS is None:
oo.hS = _N.zeros(oo.histknots)
if oo.dohist:
_N.dot(Hbf, oo.hS, out=oo.loghist)
oo.stitch_Hist(ARo, oo.loghist, Msts)
## ORDER OF SAMPLING
## f_xx, f_V
## DA: PG, kpOws
## history, build ARo
## psth
## offset
## DA: latent state
## AR coefficients
## q2
K = _N.empty((oo.TR, oo.N + 1, oo.k)) # kalman gain
iterBLOCKS = oo.ITERS // oo.peek
smpx_tmp = _N.empty((oo.TR, oo.N + 1, oo.k))
###### Gibbs sampling procedure
for itrB in range(iterBLOCKS):
it = itrB * oo.peek
if it > 0:
print("it: %(it)d mnStd %(mnstd).3f" % {
"it": itrB * oo.peek,
"mnstd": oo.mnStds[it - 1]
})
#tttA = _tm.time()
for it in range(itrB * oo.peek, (itrB + 1) * oo.peek):
#ttt1 = _tm.time()
# generate latent AR state
oo.f_x[:, 0] = oo.x00
if it == 0:
for m in range(ooTR):
oo.f_V[m, 0] = oo.s2_x00
else:
oo.f_V[:, 0] = _N.mean(oo.f_V[:, 1:], axis=1)
### PG latent variable sample
#ttt2 = _tm.time()
for m in range(ooTR):
lw.rpg_devroye(oo.rn,
oo.smpx[m, 2:, 0] + oo.us[m] + BaS +
ARo[m] + oo.knownSig[m],
out=oo.ws[m]) ###### devryoe
#ttt3 = _tm.time()
if ooTR == 1:
oo.ws = oo.ws.reshape(1, ooN + 1)
_N.divide(oo.kp, oo.ws, out=kpOws)
if oo.dohist:
O = kpOws - oo.smpx[..., 2:, 0] - oo.us.reshape(
(ooTR, 1)) - BaS - oo.knownSig
if it == 2000:
_N.savetxt("it2000.dat", O)
iOf = vInds[0] # offset HcM index with RHS index.
#print(oo.ws)
for i in vInds:
#print("i %d" % i)
#print(_N.sum(HbfExpd[i]))
for j in vInds:
#print("j %d" % j)
#print(_N.sum(HbfExpd[j]))
HcM[i - iOf, j - iOf] = _N.sum(oo.ws * HbfExpd[i] *
HbfExpd[j])
RHS[i, 0] = _N.sum(oo.ws * HbfExpd[i] * O)
for cj in cInds:
RHS[i, 0] -= _N.sum(
oo.ws * HbfExpd[i] * HbfExpd[cj]) * RHS[cj, 0]
# print("HbfExpd..............................")
# print(HbfExpd)
# print("HcM..................................")
# print(HcM)
# print("RHS..................................")
# print(RHS[vInds])
vm = _N.linalg.solve(HcM, RHS[vInds])
Cov = _N.linalg.inv(HcM)
#print vm
#print(Cov)
#print(vm[:, 0])
cfs = _N.random.multivariate_normal(vm[:, 0], Cov, size=1)
RHS[vInds, 0] = cfs[0]
oo.smp_hS[:, it] = RHS[:, 0]
#RHS[2:6, 0] = vm[:, 0]
#vv = _N.dot(Hbf, RHS)
#print vv.shape
#print oo.loghist.shape
_N.dot(Hbf, RHS[:, 0], out=oo.loghist)
oo.smp_hist[:, it] = oo.loghist
oo.stitch_Hist(ARo, oo.loghist, Msts)
else:
oo.smp_hist[:, it] = oo.loghist
oo.stitch_Hist(ARo, oo.loghist, Msts)
# Now that we have PG variables, construct Gaussian timeseries
# ws(it+1) using u(it), F0(it), smpx(it)
# cov matrix, prior of aS
# oo.gau_obs = kpOws - BaS - ARo - oous_rs - oo.knownSig
# oo.gau_var =1 / oo.ws # time dependent noise
#ttt4 = _tm.time()
if oo.bpsth:
Oms = kpOws - oo.smpx[..., 2:,
0] - ARo - oous_rs - oo.knownSig
_N.einsum("mn,mn->n", oo.ws, Oms, out=smWimOm) # sum over
ilv_f = _N.diag(_N.sum(oo.ws, axis=0))
# diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
_N.fill_diagonal(lv_f, 1. / _N.diagonal(ilv_f))
lm_f = _N.dot(lv_f, smWimOm) # nondiag of 1./Bi are inf
# now sample
iVAR = _N.dot(oo.B, _N.dot(ilv_f, oo.B.T)) + iD_f
#ttt4a = _tm.time()
VAR = _N.linalg.inv(iVAR) # knots x knots
#ttt4b = _tm.time()
#iBDBW = _N.linalg.inv(BDB + lv_f) # BDB not diag
#Mn = oo.u_a + _N.dot(DB, _N.dot(iBDBW, lm_f - BTua))
# BDB + lv_f (N+1 x N+1)
# lm_f - BTua (N+1)
Mn = oo.u_a + _N.dot(
DB, _N.linalg.solve(BDB + lv_f, lm_f - BTua))
#t4c = _tm.time()
oo.aS = _N.random.multivariate_normal(Mn, VAR,
size=1)[0, :]
oo.smp_aS[it, :] = oo.aS
_N.dot(oo.B.T, oo.aS, out=BaS)
#ttt5 = _tm.time()
######## per trial offset sample burns==None, only psth fit
Ons = kpOws - oo.smpx[..., 2:, 0] - ARo - BaS - oo.knownSig
# solve for the mean of the distribution
if not oo.bpsth: # if not doing PSTH, don't constrain offset, as there are no confounds controlling offset
_N.einsum("mn,mn->m", oo.ws, Ons,
out=smWinOn) # sum over trials
ilv_u = _N.diag(_N.sum(oo.ws, axis=1)) # var of LL
# diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
_N.fill_diagonal(lv_u, 1. / _N.diagonal(ilv_u))
lm_u = _N.dot(
lv_u, smWinOn) # nondiag of 1./Bi are inf, mean LL
# now sample
iVAR = ilv_u + iD_u
VAR = _N.linalg.inv(iVAR) #
Mn = _N.dot(VAR, _N.dot(ilv_u, lm_u) + iD_u_u_u)
oo.us[:] = _N.random.multivariate_normal(Mn, VAR,
size=1)[0, :]
if not oo.bIndOffset:
oo.us[:] = _N.mean(oo.us)
oo.smp_u[:, it] = oo.us
else:
H = _N.ones((oo.TR - 1, oo.TR - 1)) * _N.sum(oo.ws[0])
uRHS = _N.empty(oo.TR - 1)
for dd in range(1, oo.TR):
H[dd - 1, dd - 1] += _N.sum(oo.ws[dd])
uRHS[dd - 1] = _N.sum(oo.ws[dd] * Ons[dd] -
oo.ws[0] * Ons[0])
MM = _N.linalg.solve(H, uRHS)
Cov = _N.linalg.inv(H)
oo.us[1:] = _N.random.multivariate_normal(MM, Cov, size=1)
oo.us[0] = -_N.sum(oo.us[1:])
if not oo.bIndOffset:
oo.us[:] = _N.mean(oo.us)
oo.smp_u[:, it] = oo.us
# Ons = kpOws - ARo
# _N.einsum("mn,mn->m", oo.ws, Ons, out=smWinOn) # sum over trials
# ilv_u = _N.diag(_N.sum(oo.ws, axis=1)) # var of LL
# # diag(_N.linalg.inv(Bi)) == diag(1./Bi). Bii = inv(Bi)
# _N.fill_diagonal(lv_u, 1./_N.diagonal(ilv_u))
# lm_u = _N.dot(lv_u, smWinOn) # nondiag of 1./Bi are inf, mean LL
# # now sample
# iVAR = ilv_u + iD_u
# VAR = _N.linalg.inv(iVAR) #
# Mn = _N.dot(VAR, _N.dot(ilv_u, lm_u) + iD_u_u_u)
# oo.us[:] = _N.random.multivariate_normal(Mn, VAR, size=1)[0, :]
# if not oo.bIndOffset:
# oo.us[:] = _N.mean(oo.us)
# oo.smp_u[:, it] = oo.us
#ttt6 = _tm.time()
if not oo.noAR:
# _d.F, _d.N, _d.ks,
#_kfar.armdl_FFBS_1itrMP(oo.gau_obs, oo.gau_var, oo.Fs, _N.linalg.inv(oo.Fs), oo.q2, oo.Ns, oo.ks, oo.f_x, oo.f_V, oo.p_x, oo.p_V, oo.smpx, K)
oo.gau_obs = kpOws - BaS - ARo - oous_rs - oo.knownSig
oo.gau_var = 1 / oo.ws # time dependent noise
_kfar.armdl_FFBS_1itrMP(oo.gau_obs, oo.gau_var, oo.Fs,
_N.linalg.inv(oo.Fs), oo.q2, oo.Ns,
oo.ks, oo.f_x, oo.f_V, oo.p_x,
oo.p_V, smpx_tmp, K)
oo.smpx[:, 2:] = smpx_tmp
oo.smpx[:, 1, 0:ook - 1] = oo.smpx[:, 2, 1:]
oo.smpx[:, 0, 0:ook - 2] = oo.smpx[:, 2, 2:]
if oo.doBsmpx and (it % oo.BsmpxSkp == 0):
oo.Bsmpx[:, it // oo.BsmpxSkp, 2:] = oo.smpx[:, 2:, 0]
#oo.Bsmpx[it // oo.BsmpxSkp, :, 2:] = oo.smpx[:, 2:, 0]
stds = _N.std(oo.smpx[:, 2 + oo.ignr:, 0], axis=1)
oo.mnStds[it] = _N.mean(stds, axis=0)
#ttt7 = _tm.time()
if not oo.bFixF:
#ARcfSmpl(oo.lfc, ooN+1-oo.ignr, ook, oo.AR2lims, oo.smpx[:, 1+oo.ignr:, 0:ook], oo.smpx[:, oo.ignr:, 0:ook-1], oo.q2, oo.R, oo.Cs, oo.Cn, alpR, alpC, oo.TR, prior=oo.use_prior, accepts=8, aro=oo.ARord, sig_ph0L=oo.sig_ph0L, sig_ph0H=oo.sig_ph0H)
ARcfSmpl(ooN + 1 - oo.ignr,
ook,
oo.AR2lims,
oo.smpx[:, 1 + oo.ignr:, 0:ook],
oo.smpx[:, oo.ignr:, 0:ook - 1],
oo.q2,
oo.R,
oo.Cs,
oo.Cn,
alpR,
alpC,
oo.TR,
prior=oo.use_prior,
accepts=8,
aro=oo.ARord,
sig_ph0L=oo.sig_ph0L,
sig_ph0H=oo.sig_ph0H)
oo.F_alfa_rep = alpR + alpC # new constructed
prt, rank, f, amp = ampAngRep(oo.F_alfa_rep,
f_order=True)
#print prt
#ut, wt = FilteredTimeseries(ooN+1, ook, oo.smpx[:, 1:, 0:ook], oo.smpx[:, :, 0:ook-1], oo.q2, oo.R, oo.Cs, oo.Cn, alpR, alpC, oo.TR)
#ranks[it] = rank
oo.allalfas[it] = oo.F_alfa_rep
for m in range(ooTR):
#oo.wts[m, it, :, :] = wt[m, :, :, 0]
#oo.uts[m, it, :, :] = ut[m, :, :, 0]
if not oo.bFixF:
oo.amps[it, :] = amp
oo.fs[it, :] = f
oo.F0 = (-1 *
_Npp.polyfromroots(oo.F_alfa_rep)[::-1].real)[1:]
for tr in range(oo.TR):
oo.Fs[tr, 0] = oo.F0[:]
# sample u WE USED TO Do this after smpx
# u(it+1) using ws(it+1), F0(it), smpx(it+1), ws(it+1)
oo.a2 = oo.a_q2 + 0.5 * (ooTR * ooN + 2) # N + 1 - 1
#oo.a2 = 0.5*(ooTR*(ooN-oo.ignr) + 2) # N + 1 - 1
BB2 = oo.B_q2
#BB2 = 0
for m in range(ooTR):
# set x00
oo.x00[m] = oo.smpx[m, 2] * 0.1
##################### sample q2
rsd_stp = oo.smpx[m, 3 + oo.ignr:, 0] - _N.dot(
oo.smpx[m, 2 + oo.ignr:-1], oo.F0).T
#oo.rsds[it, m] = _N.dot(rsd_stp, rsd_stp.T)
BB2 += 0.5 * _N.dot(rsd_stp, rsd_stp.T)
oo.q2[:] = _ss.invgamma.rvs(oo.a2, scale=BB2)
oo.smp_q2[:, it] = oo.q2
#ttt8 = _tm.time()
# print("--------------------------------")
# print ("t2-t1 %.4f" % (#ttt2-#ttt1))
# print ("t3-t2 %.4f" % (#ttt3-#ttt2))
# print ("t4-t3 %.4f" % (#ttt4-#ttt3))
# # print ("t4b-t4a %.4f" % (t4b-t4a))
# # print ("t4c-t4b %.4f" % (t4c-t4b))
# # print ("t4-t4c %.4f" % (t4-t4c))
# print ("t5-t4 %.4f" % (#ttt5-#ttt4))
# print ("t6-t5 %.4f" % (#ttt6-#ttt5))
# print ("t7-t6 %.4f" % (#ttt7-#ttt6))
# print ("t8-t7 %.4f" % (#ttt8-#ttt7))
#tttB = _tm.time()
#print("#tttB - #tttA %.4f" % (#tttB - #tttA))
oo.last_iter = it
if it > oo.minITERS:
smps = _N.empty((3, it + 1))
smps[0, :it + 1] = oo.amps[:it + 1, 0]
smps[1, :it + 1] = oo.fs[:it + 1, 0]
smps[2, :it + 1] = oo.mnStds[:it + 1]
#frms = _mg.stationary_from_Z_bckwd(smps, blksz=oo.peek)
if _mg.stationary_test(oo.amps[:it + 1, 0],
oo.fs[:it + 1, 0],
oo.mnStds[:it + 1],
it + 1,
blocksize=oo.mg_blocksize,
points=oo.mg_points):
break
"""
fig = _plt.figure(figsize=(8, 8))
fig.add_subplot(3, 1, 1)
_plt.plot(range(1, it), oo.amps[1:it, 0], color="grey", lw=1.5)
_plt.plot(range(0, it), oo.amps[0:it, 0], color="black", lw=3)
_plt.ylabel("amp")
fig.add_subplot(3, 1, 2)
_plt.plot(range(1, it), oo.fs[1:it, 0]/(2*oo.dt), color="grey", lw=1.5)
_plt.plot(range(0, it), oo.fs[0:it, 0]/(2*oo.dt), color="black", lw=3)
_plt.ylabel("f")
fig.add_subplot(3, 1, 3)
_plt.plot(range(1, it), oo.mnStds[1:it], color="grey", lw=1.5)
_plt.plot(range(0, it), oo.mnStds[0:it], color="black", lw=3)
_plt.ylabel("amp")
_plt.xlabel("iter")
_plt.savefig("%(dir)stmp-fsamps%(it)d" % {"dir" : oo.mcmcRunDir, "it" : it+1})
fig.subplots_adjust(left=0.15, bottom=0.15, right=0.95, top=0.95)
_plt.close()
"""
#if it - frms > oo.stationaryDuration:
# break
oo.dump_smps(0, toiter=(it + 1), dir=oo.mcmcRunDir)
oo.VIS = ARo # to examine this from outside
def run_n_dimension(args, radius, eigvals):
num_points = args.num_points
eps = args.eps
power = args.power
real = args.real
by_coeffs = args.coeffs
dim = args.dimension
root_pts = {}
residuals = {}
powerpolys = []
chebpolys = []
if by_coeffs:
for i in range(dim):
from numalgsolve.polynomial import getPoly
powerpolys.append(getPoly(num_points, dim, power=True))
chebpolys.append(getPoly(num_points, dim, power=False))
else:
r = np.random.random((num_points, dim)) * radius + eps
roots = 2 * r - radius
root_pts = {'roots': np.array(list(product(*np.rot90(roots))))}
for i in range(dim):
coeffs = np.zeros((num_points + 1, ) * dim)
idx = [
slice(None),
] * dim
idx[i] = 0
coeffs[tuple(idx)] = polyfromroots(roots[:, i])
lt = [0] * dim
lt[i] = num_points
powerpolys.append(
MultiPower(coeffs)) #, lead_term=lt, clean_zeros=False))
coeffs[tuple(idx)] = chebfromroots(roots[:, i])
chebpolys.append(
MultiCheb(coeffs)) #, lead_term=lt, clean_zeros=False))
# plt.subplot(121);plt.imshow(coeffs);plt.subplot(122);plt.imshow(chebpolys[0].coeff);plt.show()
for solver in all_solvers:
if not isinstance(solver, OneDSolver) and solver.basis in [
'power', 'both'
]:
# if ((not eigvals) or solver.eigvals):
name = str(solver) + ' Power'
root_pts[name] = solver(powerpolys)
residuals[name] = maximal_residual(powerpolys, root_pts[name])
for solver in all_solvers:
if not isinstance(solver, OneDSolver) and solver.basis in [
'cheb', 'both'
]:
# if ((not eigvals) or solver.eigvals):
name = str(solver) + ' Cheb'
root_pts[name] = solver(chebpolys)
residuals[name] = maximal_residual(chebpolys, root_pts[name])
if args.hist:
evaluations = {}
for k, v in root_pts.items():
if k == 'roots': continue
# evaluations[k] = []
polys = powerpolys if 'Power' in k else chebpolys
# for poly in polys:
evaluations[k] = sum(np.abs(poly(root_pts[k])) for poly in polys)
ncols = len(evaluations)
# plt.figure(figsize=(12,6))
fig, ax = plt.subplots(1, ncols, sharey=True, figsize=(12, 4))
minimal = -15
maximal = 1
for i, (k, v) in enumerate(evaluations.items()):
ax[i].hist(np.clip(np.log10(v), minimal, maximal),
range=(minimal, maximal),
bins=40)
ax[i].set_xlabel(r'$log_{10}(p(r_i))$')
ax[i].set_title(k)
plt.suptitle("Eigenvalues" if eigvals else "Eigenvectors")
plt.show()
return root_pts, residuals
def get_alpha_and_beta(arroots, maroots):
alpha = polyfromroots(arroots)
beta = polyfromroots(maroots)
beta /= beta[0]
return alpha, beta
from matplotlib.colors import LinearSegmentedColormap
import numpy.polynomial.polynomial as nppoly
import pdb
numFreqs = 1000
T_incr = 0.02
T = 4000
colormapping = {'0': '#a6cee3', '2': '#b2df8a', '4': '#fb9a99', '6': '#fdbf6f', '8': '#cab2d6', '10': '#ffff99'}
freqs = np.logspace(m.log10(1./T),m.log10(1./T_incr),numFreqs)
#aListRoots = [-0.73642081+0j, -0.01357919+0j, -0.025-0.75j, -0.025+0.75j]
aListRoots = [-0.73642081+0j, -0.01357919+0j]
aPoly = nppoly.polyfromroots(aListRoots)
aPoly = aPoly.tolist()
aPoly.reverse()
aPoly.pop(0)
aPoly = [coeff.real for coeff in aPoly]
print "aPoly"
print aPoly
#aList = [0.75,0.01]
aList = aPoly
bList = [1.16e-9,6.8e-9]
if (CF.checkParams(aList,bList) == 1):
maxDenomOrder = 2*len(aList)
def nonlinearphase_channel(x, taps = 5, debug = False):
'''
*SOME TESTING, BUGGY*
Implements an all pass filter (flat frequency response). The plan was to
generate an all pass filter with a very ugly phase response by generating
random taps (while maintaining flat frequency response). However, this does
not actually do what I hoped it would. I expected a terribly ugly
phase response. However, the phase response of this random IIR filter turns
out to actually be pretty linear...
The frequency response seems to also SOMTIMES output some crazy behaviour as
the frequency gets close to pi. Would be wise to use with debug = True.
'''
bar = Bar('Passing through nonlinearphase channel...', max = taps + 1)
bar.next()
rnge = (0.2, 0.80)
P = [] #Poles
if taps % 2 == 0:
pass
else:
taps = taps - 1
p = random.uniform(*rnge)
p = random.choice([-1,1])*p
P.append(p)
for i in range(taps):
p_real = random.uniform(*rnge)
p_real = random.choice([-1, 1])*p_real
p_imag = random.uniform (0.2, 0.80*sqrt(1 - p_real**2))
p_imag = random.choice([-1, 1])*p_imag
p1 = p_real + (1j)*p_imag #1j is an imaginary number
p2 = p_real + (1j)*(-1)*p_imag
P.append(p1)
P.append(p2)
bar.next()
a = poly.polyfromroots(P) #a is the 'a' coefficients of the IIR filter
b = np.conj(a) #b must be the reversed & conjugated coefficients of a
b = np.array(list(reversed(b)))
#The polynomial library stores it's coefficients in the opposite order
#of scipy.signal. So i reverse both here again.
#Reversing a twice brings it back to it's original form, but I am hopefully
#avoiding some confusion because it is being done for 2 different reasons.
b = np.array(list(reversed(b)))
a = np.array(list(reversed(a)))
if debug == True:
plot_filter(b,a)
plot_filter_pz(b,a)
x = lfilter(b, a, x)
max_ampl = max(max(x), -1*min(x))
x = x/max_ampl
bar.next()
bar.finish()
return x
import matplotlib.pyplot as plt import random from collections import namedtuple import numpy as np import numpy.polynomial.polynomial as polynomial import tensorflow as tf random.seed(234921) # make a polynomial with the given number of roots, but no root at 0 poly_degree = 7 poly_roots = list(np.arange(poly_degree + 1) - int(poly_degree / 2)) poly_roots.remove(0) poly_roots = np.array(poly_roots) poly_coeffs = polynomial.polyfromroots(poly_roots) deltax = 0.1 x_all = np.arange(poly_roots[0] - 0.2, poly_roots[-1] + 0.2, deltax) y_all = polynomial.polyval(x_all, poly_coeffs) number_points_to_train = 20 number_points_to_test = 20 inds = range(len(x_all)) random.shuffle(inds) x_train = x_all[inds[0:number_points_to_train]] y_train = y_all[inds[0:number_points_to_train]] x_test = x_all[inds[number_points_to_train : (number_points_to_train + number_points_to_test)]] y_test = y_all[inds[number_points_to_train : (number_points_to_train + number_points_to_test)]]
