def plot_ibd_total(c):
'''Plot Oren's total genomic IBD % vs. kinship, displaying the trend of IBD.'''
i = np.where(c[:, 4] > 0)[0]
t, ibd = c[i, 3], (1.0 * c[i, 4]) / sum(ChromDao.TOTAL_BP_TYPED)
# Fix HBD probabilities to account for the probability that one can choose the same haplotype twice.
# (We only account for the probability of the two different haps being equal in c[i,4].)
hbd = np.where(c[:, 0] == c[:, 1])[0]
ibd[hbd] = 0.5 * (1 + ibd[hbd])
j = i[np.where(c[:, 0] != c[:, 1])[0]]
a, b, r, _, stderr = stats.linregress(t[j], ibd[j])
xr = polyval([a, b], t[j])
P.figure(1)
P.clf()
P.hold(True)
P.scatter(t, ibd, s=2, lw=0, color='b')
P.plot(t[j], xr, 'r-')
T = np.arange(0, 1, 0.01)
P.plot(T, T, 'g-')
P.xlim([-0.01, 1.01])
P.ylim([-0.01, 1.01])
P.title(' %% IBD of Whole Genome vs. Expected %%\nslope = %.2f, intercept = %.2f, r = %.2f, std error = %.2e' % (a, b, r, stderr))
P.xlabel('$\gamma := \Delta_1+\Delta_3+\Delta_5+\Delta_7+\Delta_8$: Empirical ID Coefficients')
P.ylabel('$i = $ % IBD in Oren''s Code')
P.show()
return t, ibd
def seprate(numberator, roots):
# seprates a fraction
tempRes = []
for i in roots:
temp = P.poly1d([complex(1, 0)])
for j in roots:
if not i == j:
temp = temp * P.poly1d([complex(1, 0), -j])
tempRes += [P.polyval(numberator, i) / P.polyval(temp, i)]
res = []
for i in range(0, len(tempRes)):
s = tempRes[i]
m = P.poly1d([complex(1, 0), -roots[i]])
k = [s, roots[i]]
res += [k]
return res
def plot_ibd_total(c):
'''Plot Oren's total genomic IBD % vs. kinship, displaying the trend of IBD.'''
i = np.where(c[:, 4] > 0)[0]
t, ibd = c[i, 3], (1.0 * c[i, 4]) / sum(ChromDao.TOTAL_BP_TYPED)
# Fix HBD probabilities to account for the probability that one can choose the same haplotype twice.
# (We only account for the probability of the two different haps being equal in c[i,4].)
hbd = np.where(c[:, 0] == c[:, 1])[0]
ibd[hbd] = 0.5 * (1 + ibd[hbd])
j = i[np.where(c[:, 0] != c[:, 1])[0]]
a, b, r, _, stderr = stats.linregress(t[j], ibd[j])
xr = polyval([a, b], t[j])
P.figure(1)
P.clf()
P.hold(True)
P.scatter(t, ibd, s=2, lw=0, color='b')
P.plot(t[j], xr, 'r-')
T = np.arange(0, 1, 0.01)
P.plot(T, T, 'g-')
P.xlim([-0.01, 1.01])
P.ylim([-0.01, 1.01])
P.title(
' %% IBD of Whole Genome vs. Expected %%\nslope = %.2f, intercept = %.2f, r = %.2f, std error = %.2e'
% (a, b, r, stderr))
P.xlabel(
'$\gamma := \Delta_1+\Delta_3+\Delta_5+\Delta_7+\Delta_8$: Empirical ID Coefficients'
)
P.ylabel('$i = $ % IBD in Oren' 's Code')
P.show()
return t, ibd
def simplize(numberator, denominator, roots):
# simplizes the numberator and Denominator
counter = 0
for i in roots:
if P.polyval(numberator, i) == 0:
numberator = P.polydiv(numberator, polyFromRoot([i]))
numberator = numberator[0]
denominator = P.polydiv(denominator, polyFromRoot([i]))
denominator = denominator[0]
roots = roots[:counter] + roots[counter + 1:]
counter += 1
return [numberator, denominator, roots]
def get_level_parameters(cls, level):
"""
:param int level: Liczba całkowita większa od jendości.
:return: Zwraca listę współczynników dla poszczególnych puktów
w metodzie NC. Na przykład metoda NC stopnia 2 używa punktów
na początku i końcu przedziału i każdy ma współczynnik 1,
więc metoda ta zwraca [1, 1]. Dla NC 3 stopnia będzie to
[1, 3, 1] itp.
:rtype: List of integers
"""
paramList = []
for elem in range(level):
param = 1
for i in range(level):
if elem != i:
param = param*poly1d([1, -i])
param = polyint(param)
param = polyval(param,level-1)-polyval(param,0)
a = math.pow(-1,level-elem-1)/math.factorial(elem)/math.factorial(level-elem-1)
paramList.append(param*a)
return paramList
def psi(self, t):
"""DOG wavelet as described in Torrence and Compo (1998)
The derivative of a Gaussian of order n can be determined using
the probabilistic Hermite polynomials. They are explicitly
written as:
Hn(x) = 2 ** (-n / s) * n! * sum ((-1) ** m) * (2 ** 0.5 *
x) ** (n - 2 * m) / (m! * (n - 2*m)!)
or in the recursive form:
Hn(x) = x * Hn(x) - nHn-1(x)
Source: http://www.ask.com/wiki/Hermite_polynomials
"""
p = hermitenorm(self.m)
return (-1) ** (self.m + 1) * polyval(p, t) * np.exp(-t ** 2 / 2) / np.sqrt(gamma(self.m + 0.5))
def psi(self, t):
"""DOG wavelet as described in Torrence and Compo (1998)
The derivative of a Gaussian of order n can be determined using
the probabilistic Hermite polynomials. They are explicitly
written as:
Hn(x) = 2 ** (-n / s) * n! * sum ((-1) ** m) * (2 ** 0.5 *
x) ** (n - 2 * m) / (m! * (n - 2*m)!)
or in the recursive form:
Hn(x) = x * Hn(x) - nHn-1(x)
Source: http://www.ask.com/wiki/Hermite_polynomials
"""
p = hermitenorm(self.m)
return ((-1)**(self.m + 1) * polyval(p, t) * np.exp(-t**2 / 2) /
np.sqrt(gamma(self.m + 0.5)))
def list_derivative(f, x, n, o=3, p=5):
"""
Returns the nth derivative of f with respect to x, where zip(x,f) are
datapoints, using curve-fit polynomials of order o to p points.
"""
assert p % 2 == 1 # should be odd imo
assert len(f) >= p # won't work otherwise
derivative = []
for i in xrange(len(f)):
start = i - (p - 1) / 2
if start < 0:
start = 0
end = start + p
if end >= len(f):
start = -1 - p
end = -1
spline = polyfit(x[start:end], f[start:end], o)
derivative.append(polyval(polyder(spline, n), x[i]))
print("diff in list lengths: " + str(len(f) - len(derivative)))
return array(derivative)
def __iadd__(self, other):
if not (self.flag and other.flag):
raise Exception('bad arguments')
self.scatter_list.extend(other.scatter_list)
slope, intercept, r_value, p_value, std_err = stats.linregress(
self.scatter_list)
self.slope = slope
self.intercept = intercept
self.r_val = r_value
self.p_val = p_value
self.std_err = std_err
self.max = max(self.scatter_list, key=itemgetter(1))
self.min = min(self.scatter_list, key=itemgetter(1))
self.x_grid = [x for x, y in self.scatter_list]
self.line = polyval([self.slope, self.intercept], self.x_grid)
return self
def __init__(self, dStream_obj):
self.scatter_list = self.scatter_plot(dStream_obj)
self.scatter_list = [point for point in self.scatter_list if point]
if self.scatter_list:
self.flag = True
slope, intercept, r_value, p_value, std_err = stats.linregress(
self.scatter_list)
self.slope = slope
self.intercept = intercept
self.r_val = r_value
self.p_val = p_value
self.std_err = std_err
self.max = max(self.scatter_list, key=itemgetter(1))
self.min = min(self.scatter_list, key=itemgetter(1))
self.x_grid = [x for x, y in self.scatter_list]
self.line = polyval([self.slope, self.intercept], self.x_grid)
else:
self.flag = False
def wavelet_inverse(wave, scale, dt, dj=0.25, mother="MORLET", param=-1):
"""Inverse continuous wavelet transform
Torrence and Compo (1998), eq. (11)
INPUTS
waves (array like):
WAVE is the WAVELET transform. This is a complex array.
scale (array like):
the vector of scale indices
dt (float) :
amount of time between each original value, i.e. the sampling time.
dj (float, optional) :
the spacing between discrete scales. Default is 0.25.
A smaller # will give better scale resolution, but be slower to plot.
mother (string, optional) :
the mother wavelet function.
The choices are 'MORLET', 'PAUL', or 'DOG'
PARAM = the mother wavelet parameter.
For 'MORLET' this is k0 (wavenumber), default is 6.
For 'PAUL' this is m (order), default is 4.
For 'DOG' this is m (m-th derivative), default is 2.
OUTPUTS
iwave (array like) :
Inverse wavelet transform.
"""
import numpy as np
j1, n = wave.shape
J1 = len(scale)
if not j1 == J1:
print j1, n, J1
raise Exception("Input array are inconsistent")
sj = np.dot(scale.reshape(len(scale), 1), np.ones((1, n)))
#
mother = mother.upper()
# psi0 comes from Table 1,2 Torrence and Compo (1998)
# Cdelta comes from Table 2 Torrence and Compo (1998)
if mother == 'MORLET': #----------------------------------- Morlet
if (param == -1): param = 6.
psi0 = np.pi**(-0.25)
if param == 6.:
Cdelta = 0.776
elif mother == 'PAUL': #-------------------------------- Paul
if (param == -1): param = 4.
m = param
psi0 = np.real(2.**m * 1j**m * np.prod(np.arange(2, m + 1)) /
np.sqrt(np.pi * np.prod(np.arange(2, 2 * m + 1))) *
(1**(-(m + 1))))
if m == 4.:
Cdelta = 1.132
elif mother == 'DOG': #-------------------------------- DOG
if (param == -1): param = 2.
m = param
from scipy.special import gamma
from numpy.lib.polynomial import polyval
from scipy.special.orthogonal import hermitenorm
p = hermitenorm(m)
psi0 = (-1)**(m + 1) / np.sqrt(gamma(m + 0.5)) * polyval(p, 0)
print psi0
if m == 2.:
Cdelta = 3.541
if m == 6.:
Cdelta = 1.966
else:
raise Exception("Mother must be one of MORLET,PAUL,DOG")
#eq. (11) in Torrence and Compo (1998)
iwave = dj * np.sqrt(dt) / Cdelta / psi0 * (np.real(wave) /
sj**0.5).sum(axis=0)
return iwave
x= [2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015]
y = [485709,486722,475887,469311,453618,447977,436867,426885,392470,370021,351340,335504,306387,273781,238761]
p1= np.polyfit(x,y,1)
p2= np.polyfit(x,y,2)
p3= np.polyfit(x,y,3)
from scipy.interpolate import *
import matplotlib.pyplot as plt
xp = linspace(2000,2020,100)
fig,ax = plt.subplots()
plt.plot(xp,polyval(p1,xp),'r-')
plt.plot(xp,polyval(p2,xp),'m:')
plt.plot(xp,polyval(p3,xp),'b--')
ax.set_title("Prediction of Crime Data in Chicago")
ax.set_ylabel('Count')
ax.set_xlabel('Year')
plt.plot(x,y,'o')
#yfit = p1[0] * x + p1[1]
#yresid = y - yfit
#SSresid = sum(pow(yresid,2))
#SStotal = len(y) * np.var(y)
#rsq = 1- SSresid / SStotal
from scipy.stats import *
# Programa de Franco Benassi
# Proyecto #3 Interfaces Graficas 2020
# Ejercicio 3
from matplotlib.pyplot import figure
import numpy as np
from numpy.lib.polynomial import polyval
from pylab import *
recorrido = np.load(
"/home/franco-os/Documentos/Informática/Interfaces de Grafica de Usuario/Proyecto 3/datas/f1.npy"
)
recorrido2 = np.load(
"/home/franco-os/Documentos/Informática/Interfaces de Grafica de Usuario/Proyecto 3/datas/f2.npy"
)
x = np.arange(start=1, stop=50, step=1)
z = np.polyfit(x, recorrido, 1)
z_2 = np.polyfit(x, recorrido2, 2)
figure()
plot(x, recorrido, 'o')
plot(x, recorrido2, 'o')
plot(x, polyval(z, x), '-')
plot(x, polyval(z_2, x), '-')
show()
def analyze_olfaction_covariance(covariance, receptors):
''' Covariance: n x n covariance matrix.
Positions: list of n positions '''
positions = [pose.get_2d_position() for pose, sens in receptors] #@UnusedVariable
positions = array(positions).transpose().squeeze()
require_shape(square_shape(), covariance)
n = covariance.shape[0]
require_shape((2, n), positions)
distances = create_distance_matrix(positions)
correlation = cov2corr(covariance)
flat_distances = distances.reshape(n * n)
flat_correlation = correlation.reshape(n * n)
# let's fit a polynomial
deg = 4
poly = polyfit(flat_distances, flat_correlation, deg=deg)
knots = linspace(min(flat_distances), max(flat_distances), 2000)
poly_int = polyval(poly, knots)
poly_fder = polyder(poly)
fder = polyval(poly_fder, distances)
Ttheta = create_olfaction_Ttheta(positions, fder)
Tx, Ty = create_olfaction_Txy(positions, fder, distances)
report = Node('olfaction-theory')
report.data('flat_distances', flat_distances)
report.data('flat_correlation', flat_correlation)
with report.data_file('dist_vs_corr', 'image/png') as filename:
pylab.figure()
pylab.plot(flat_distances, flat_correlation, '.')
pylab.plot(knots, poly_int, 'r-')
pylab.xlabel('distance')
pylab.ylabel('correlation')
pylab.title('Correlation vs distance')
pylab.legend(['data', 'interpolation deg = %s' % deg])
pylab.savefig(filename)
pylab.close()
with report.data('fder', fder).data_file('fder', 'image/png') as filename:
pylab.figure()
pylab.plot(knots, polyval(poly_fder, knots), 'r-')
pylab.title('f der')
pylab.savefig(filename)
pylab.close()
report.data('distances', distances)
report.data('correlation', correlation)
report.data('covariance', covariance)
report.data('f', polyval(poly, distances))
f = report.figure(id='cor-vs-distnace', caption='Estimated kernels',
shape=(3, 3))
f.sub('dist_vs_corr')
f.sub('fder')
f.sub('f', display='scale')
f.sub('distances', display='scale')
f.sub('correlation', display='posneg')
f.sub('covariance', display='posneg')
T = numpy.zeros(shape=(3, Tx.shape[0], Tx.shape[1]))
T[0, :, :] = Tx
T[1, :, :] = Ty
T[2, :, :] = Ttheta
T_report = create_report_figure_tensors(T, report_id='tensors',
caption="Predicted learned tensors")
report.add_child(T_report)
return report
def wavelet_inverse(wave, scale, dt, dj=0.25, mother="MORLET",param=-1):
"""Inverse continuous wavelet transform
Torrence and Compo (1998), eq. (11)
INPUTS
waves (array like):
WAVE is the WAVELET transform. This is a complex array.
scale (array like):
the vector of scale indices
dt (float) :
amount of time between each original value, i.e. the sampling time.
dj (float, optional) :
the spacing between discrete scales. Default is 0.25.
A smaller # will give better scale resolution, but be slower to plot.
mother (string, optional) :
the mother wavelet function.
The choices are 'MORLET', 'PAUL', or 'DOG'
PARAM = the mother wavelet parameter.
For 'MORLET' this is k0 (wavenumber), default is 6.
For 'PAUL' this is m (order), default is 4.
For 'DOG' this is m (m-th derivative), default is 2.
OUTPUTS
iwave (array like) :
Inverse wavelet transform.
"""
import numpy as np
j1, n = wave.shape
J1 = len(scale)
if not j1 == J1:
print j1,n,J1
raise Exception("Input array are inconsistent")
sj = np.dot(scale.reshape(len(scale),1),np.ones((1,n)))
#
mother = mother.upper()
# psi0 comes from Table 1,2 Torrence and Compo (1998)
# Cdelta comes from Table 2 Torrence and Compo (1998)
if mother=='MORLET': #----------------------------------- Morlet
if (param == -1): param = 6.
psi0=np.pi**(-0.25)
if param==6.:
Cdelta = 0.776
elif mother=='PAUL': #-------------------------------- Paul
if (param == -1): param = 4.
m = param
psi0=np.real(2.**m*1j**m*np.prod(np.arange(2, m + 1))/np.sqrt(np.pi*np.prod(np.arange(2,2*m+1)))*(1**(-(m+1))))
if m==4.:
Cdelta = 1.132
elif mother=='DOG': #-------------------------------- DOG
if (param == -1): param = 2.
m = param
from scipy.special import gamma
from numpy.lib.polynomial import polyval
from scipy.special.orthogonal import hermitenorm
p = hermitenorm(m)
psi0=(-1)**(m+1)/np.sqrt(gamma(m+0.5))*polyval(p, 0)
print psi0
if m==2.:
Cdelta=3.541
if m==6.:
Cdelta=1.966
else:
raise Exception("Mother must be one of MORLET,PAUL,DOG")
#eq. (11) in Torrence and Compo (1998)
iwave = dj * np.sqrt(dt) / Cdelta /psi0 * (np.real(wave) / sj**0.5).sum(axis=0)
return iwave
