def GetFlow(self):
'''
Calculating inlet flow (coefficients of the FFT x(t)=A0+sum(2*Ck*exp(j*k*2*pi*f*t)))
Timestep and period from SimulationContext are necessary.
'''
try:
timestep = self.SimulationContext.Context['timestep']
except KeyError:
print "Error, Please set timestep in Simulation Context XML File"
raise
try:
period = self.SimulationContext.Context['period']
except KeyError:
print "Error, Please set period in Simulation Context XML File"
raise
t = arange(0.0,period+timestep,timestep).reshape((1,ceil(period/timestep+1.0)))
Cc = self.f_coeff*1.0/2.0*1e-6
Flow = zeros((1, ceil(period/timestep+1.0)))
for freq in arange(0,ceil(period/timestep+1.0)):
Flow[0, freq] = self.A0_v
for k in arange(0,self.f_coeff.shape[0]):
Flow[0, freq] = Flow[0, freq]+real(2.0*complex(Cc[k,0],Cc[k,1])*exp(1j*(k+1)*2.0*pi*t[0,freq]/period))
self.Flow = Flow
return Flow
def testNoisyLine1(self): x = map(lambda x: x + gauss(0,0.002), arange(-1,1,0.001)) y = map(lambda x: x + gauss(0,0.002), arange(-1,1,0.001)) z = map(lambda x: x + gauss(0,0.02), arange(-1,1,0.001)) line = array(zip(x,y,z)) lpc = LPCImpl(h = 0.2, mult = 2) lpc_curve = lpc.lpc(X = line)
def diagflat(v,k=0):
"""Return a 2D array whose k'th diagonal is a flattened v and all other
elements are zero.
Examples
--------
>>> diagflat([[1,2],[3,4]]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
>>> diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
"""
try:
wrap = v.__array_wrap__
except AttributeError:
wrap = None
v = asarray(v).ravel()
s = len(v)
n = s + abs(k)
res = zeros((n,n), v.dtype)
if (k>=0):
i = arange(0,n-k)
fi = i+k+i*n
else:
i = arange(0,n+k)
fi = i+(i-k)*n
res.flat[fi] = v
if not wrap:
return res
return wrap(res)
def GetTimeFlow(self, el, time):
'''
Calculating inlet flow (coefficients of the FFT x(t)=A0+sum(2*Ck*exp(j*k*2*pi*f*t)))
for a specific time value.
If signal is specified, flow is computed from time values.
'''
try:
period = self.SimulationContext.Context['period']
except KeyError:
print "Error, Please set period in Simulation Context XML File"
raise
try:
signal = self.InFlows[el]['signal']
try:
timestep = self.SimulationContext.Context['timestep']
except KeyError:
print "Error, Please set timestep in Simulation Context XML File"
raise
t = arange(0.0,period+timestep,timestep)
t2 = list(t)
Flow = float(signal[t2.index(time)])/6.0e7
self.Flow = Flow
return Flow
except KeyError:
f_coeff = self.InFlows[el]['f_coeff']
A0 = self.InFlows[el]['A0']
Cc = f_coeff*1.0/2.0*1e-6
Flow = A0
for k in arange(0,f_coeff.shape[0]):
Flow += real(2.0*complex(Cc[k,0],Cc[k,1])*exp(1j*(k+1)*2.0*pi*time/period))
self.Flow = Flow
return Flow
def testNoisyLine2(self): x = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005)) y = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005)) z = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005)) line = array(zip(x,y,z)) lpc = LPCImpl(h = 0.2, convergence_at = 0.001, mult = 2) lpc_curve = lpc.lpc(X = line)
def __getitem__(self, key):
try:
size = []
typ = int
for k in range(len(key)):
step = key[k].step
start = key[k].start
if start is None:
start = 0
if step is None:
step = 1
if isinstance(step, complex):
size.append(int(abs(step)))
typ = float
else:
size.append(
int(math.ceil((key[k].stop - start)/(step*1.0))))
if (isinstance(step, float) or
isinstance(start, float) or
isinstance(key[k].stop, float)):
typ = float
if self.sparse:
nn = [_nx.arange(_x, dtype=_t)
for _x, _t in zip(size, (typ,)*len(size))]
else:
nn = _nx.indices(size, typ)
for k in range(len(size)):
step = key[k].step
start = key[k].start
if start is None:
start = 0
if step is None:
step = 1
if isinstance(step, complex):
step = int(abs(step))
if step != 1:
step = (key[k].stop - start)/float(step-1)
nn[k] = (nn[k]*step+start)
if self.sparse:
slobj = [_nx.newaxis]*len(size)
for k in range(len(size)):
slobj[k] = slice(None, None)
nn[k] = nn[k][slobj]
slobj[k] = _nx.newaxis
return nn
except (IndexError, TypeError):
step = key.step
stop = key.stop
start = key.start
if start is None:
start = 0
if isinstance(step, complex):
step = abs(step)
length = int(step)
if step != 1:
step = (key.stop-start)/float(step-1)
stop = key.stop + step
return _nx.arange(0, length, 1, float)*step + start
else:
return _nx.arange(start, stop, step)
def plot2():
fig5 = plt.figure()
x = map(lambda x: x + gauss(0,0.02)*(1-x*x), arange(-1,1,0.001))
y = map(lambda x: x + gauss(0,0.02)*(1-x*x), arange(-1,1,0.001))
z = map(lambda x: x + gauss(0,0.02)*(1-x*x), arange(-1,1,0.001))
line = array(zip(x,y,z))
lpc = LPCImpl(h = 0.05, mult = 2, it = 200, cross = False, scaled = False, convergence_at = 0.001)
lpc_curve = lpc.lpc(X=line)
ax = Axes3D(fig5)
ax.set_title('testNoisyLine2')
curve = lpc_curve[0]['save_xd']
ax.scatter(x,y,z, c = 'red')
ax.plot(curve[:,0],curve[:,1],curve[:,2])
saveToPdf(fig5, '/tmp/testNoisyLine2.pdf')
residuals_calc = LPCResiduals(line, tube_radius = 0.05, k = 10)
residual_diags = residuals_calc.getPathResidualDiags(lpc_curve[0])
fig6 = plt.figure()
#plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_num_NN'], drawstyle = 'step', linestyle = '--')
plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_mean_NN'])
plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_std_NN'])
saveToPdf(fig6, '/tmp/testNoisyLine2PathResiduals.pdf')
coverage_graph = residuals_calc.getCoverageGraph(lpc_curve[0], arange(0.001, .102, 0.005))
fig7 = plt.figure()
plt.plot(coverage_graph[0],coverage_graph[1])
saveToPdf(fig7, '/tmp/testNoisyLine2Coverage.pdf')
residual_graph = residuals_calc.getGlobalResiduals(lpc_curve[0])
fig8 = plt.figure()
plt.plot(residual_graph[0], residual_graph[1])
saveToPdf(fig8, '/tmp/testNoisyLine2Residuals.pdf')
fig9 = plt.figure()
plt.plot(range(len(lpc_curve[0]['lamb'])), lpc_curve[0]['lamb'])
saveToPdf(fig9, '/tmp/testNoisyLine2PathLength.pdf')
def tri(N, M=None, k=0, dtype=float):
""" returns a N-by-M array where all the diagonals starting from
lower left corner up to the k-th are all ones.
"""
if M is None: M = N
m = greater_equal(subtract.outer(arange(N), arange(M)),-k)
return m.astype(dtype)
def diag(v, k=0):
""" returns a copy of the the k-th diagonal if v is a 2-d array
or returns a 2-d array with v as the k-th diagonal if v is a
1-d array.
"""
v = asarray(v)
s = v.shape
if len(s)==1:
n = s[0]+abs(k)
res = zeros((n,n), v.dtype)
if (k>=0):
i = arange(0,n-k)
fi = i+k+i*n
else:
i = arange(0,n+k)
fi = i+(i-k)*n
res.flat[fi] = v
return res
elif len(s)==2:
N1,N2 = s
if k >= 0:
M = min(N1,N2-k)
i = arange(0,M)
fi = i+k+i*N2
else:
M = min(N1+k,N2)
i = arange(0,M)
fi = i + (i-k)*N2
return v.flat[fi]
else:
raise ValueError, "Input must be 1- or 2-d."
def helixHeteroscedasticDiags():
#Parameterise a helix (no noise)
fig5 = plt.figure()
t = arange(-1,1,0.0005)
x = map(lambda x: x + gauss(0,0.001 + 0.001*sin(2*pi*x)**2), (1 - t*t)*sin(4*pi*t))
y = map(lambda x: x + gauss(0,0.001 + 0.001*sin(2*pi*x)**2), (1 - t*t)*cos(4*pi*t))
z = map(lambda x: x + gauss(0,0.001 + 0.001*sin(2*pi*x)**2), t)
line = array(zip(x,y,z))
lpc = LPCImpl(h = 0.1, t0 = 0.1, mult = 1, it = 500, scaled = False, cross = False)
lpc_curve = lpc.lpc(X=line)
ax = Axes3D(fig5)
ax.set_title('helixHeteroscedastic')
curve = lpc_curve[0]['save_xd']
ax.scatter(x,y,z, c = 'red')
ax.plot(curve[:,0],curve[:,1],curve[:,2])
saveToPdf(fig5, '/tmp/helixHeteroscedastic.pdf')
residuals_calc = LPCResiduals(line, tube_radius = 0.2, k = 20)
residual_diags = residuals_calc.getPathResidualDiags(lpc_curve[0])
fig6 = plt.figure()
#plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_num_NN'], drawstyle = 'step', linestyle = '--')
plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_mean_NN'])
plt.plot(lpc_curve[0]['lamb'][1:], residual_diags['line_seg_std_NN'])
saveToPdf(fig6, '/tmp/helixHeteroscedasticPathResiduals.pdf')
coverage_graph = residuals_calc.getCoverageGraph(lpc_curve[0], arange(0.01, .052, 0.01))
fig7 = plt.figure()
plt.plot(coverage_graph[0],coverage_graph[1])
saveToPdf(fig7, '/tmp/helixHeteroscedasticCoverage.pdf')
residual_graph = residuals_calc.getGlobalResiduals(lpc_curve[0])
fig8 = plt.figure()
plt.plot(residual_graph[0], residual_graph[1])
saveToPdf(fig8, '/tmp/helixHeteroscedasticResiduals.pdf')
fig9 = plt.figure()
plt.plot(range(len(lpc_curve[0]['lamb'])), lpc_curve[0]['lamb'])
saveToPdf(fig9, '/tmp/helixHeteroscedasticPathLength.pdf')
def eye(N, M=None, k=0, dtype=float):
""" eye returns a N-by-M 2-d array where the k-th diagonal is all ones,
and everything else is zeros.
"""
if M is None: M = N
m = equal(subtract.outer(arange(N), arange(M)),-k)
if m.dtype != dtype:
return m.astype(dtype)
def diagflat(v, k=0):
"""
Create a two-dimensional array with the flattened input as a diagonal.
Parameters
----------
v : array_like
Input data, which is flattened and set as the `k`-th
diagonal of the output.
k : int, optional
Diagonal to set; 0, the default, corresponds to the "main" diagonal,
a positive (negative) `k` giving the number of the diagonal above
(below) the main.
Returns
-------
out : ndarray
The 2-D output array.
See Also
--------
diag : MATLAB work-alike for 1-D and 2-D arrays.
diagonal : Return specified diagonals.
trace : Sum along diagonals.
Examples
--------
>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
"""
try:
wrap = v.__array_wrap__
except AttributeError:
wrap = None
v = asarray(v).ravel()
s = len(v)
n = s + abs(k)
res = zeros((n, n), v.dtype)
if k >= 0:
i = arange(0, n - k, dtype=intp)
fi = i + k + i * n
else:
i = arange(0, n + k, dtype=intp)
fi = i + (i - k) * n
res.flat[fi] = v
if not wrap:
return res
return wrap(res)
def diagflat(v, k=0):
"""
Create a two-dimensional array with the flattened input as a diagonal.
Parameters
----------
v : array_like
Input data, which is flattened and set as the `k`-th
diagonal of the output.
k : int, optional
Diagonal to set; 0, the default, corresponds to the "main" diagonal,
a positive (negative) `k` giving the number of the diagonal above
(below) the main.
Returns
-------
out : ndarray
The 2-D output array.
See Also
--------
diag : MATLAB work-alike for 1-D and 2-D arrays.
diagonal : Return specified diagonals.
trace : Sum along diagonals.
Examples
--------
>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
"""
try:
wrap = v.__array_wrap__
except AttributeError:
wrap = None
v = asarray(v).ravel()
s = len(v)
n = s + abs(k)
res = zeros((n,n), v.dtype)
if (k >= 0):
i = arange(0,n-k)
fi = i+k+i*n
else:
i = arange(0,n+k)
fi = i+(i-k)*n
res.flat[fi] = v
if not wrap:
return res
return wrap(res)
def __getitem__(self, key):
try:
size = []
typ = int
for k in range(len(key)):
step = key[k].step
start = key[k].start
if start is None: start = 0
if step is None: step = 1
if isinstance(step, complex):
size.append(int(abs(step)))
typ = float
else:
size.append(
int(math.ceil((key[k].stop - start) / (step * 1.0))))
if isinstance(step, float) or \
isinstance(start, float) or \
isinstance(key[k].stop, float):
typ = float
if self.sparse:
nn = [
_nx.arange(_x, dtype=_t)
for _x, _t in zip(size, (typ, ) * len(size))
]
else:
nn = _nx.indices(size, typ)
for k in range(len(size)):
step = key[k].step
start = key[k].start
if start is None: start = 0
if step is None: step = 1
if isinstance(step, complex):
step = int(abs(step))
if step != 1:
step = (key[k].stop - start) / float(step - 1)
nn[k] = (nn[k] * step + start)
if self.sparse:
slobj = [_nx.newaxis] * len(size)
for k in range(len(size)):
slobj[k] = slice(None, None)
nn[k] = nn[k][slobj]
slobj[k] = _nx.newaxis
return nn
except (IndexError, TypeError):
step = key.step
stop = key.stop
start = key.start
if start is None: start = 0
if isinstance(step, complex):
step = abs(step)
length = int(step)
if step != 1:
step = (key.stop - start) / float(step - 1)
stop = key.stop + step
return _nx.arange(0, length, 1, float) * step + start
else:
return _nx.arange(start, stop, step)
def diag(v, k=0):
"""
Extract a diagonal or construct a diagonal array.
Parameters
----------
v : array_like
If `v` is a 2-dimensional array, return a copy of
its `k`-th diagonal. If `v` is a 1-dimensional array,
return a 2-dimensional array with `v` on the `k`-th diagonal.
k : int, optional
Diagonal in question. The defaults is 0.
Examples
--------
>>> x = np.arange(9).reshape((3,3))
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(np.diag(x))
array([[0, 0, 0],
[0, 4, 0],
[0, 0, 8]])
"""
v = asarray(v)
s = v.shape
if len(s)==1:
n = s[0]+abs(k)
res = zeros((n,n), v.dtype)
if (k>=0):
i = arange(0,n-k)
fi = i+k+i*n
else:
i = arange(0,n+k)
fi = i+(i-k)*n
res.flat[fi] = v
return res
elif len(s)==2:
N1,N2 = s
if k >= 0:
M = min(N1,N2-k)
i = arange(0,M)
fi = i+k+i*N2
else:
M = min(N1+k,N2)
i = arange(0,M)
fi = i + (i-k)*N2
return v.flat[fi]
else:
raise ValueError, "Input must be 1- or 2-d."
def diag(v, k=0):
"""
Extract a diagonal or construct a diagonal array.
Parameters
----------
v : array_like
If `v` is a 2-dimensional array, return a copy of
its `k`-th diagonal. If `v` is a 1-dimensional array,
return a 2-dimensional array with `v` on the `k`-th diagonal.
k : int, optional
Diagonal in question. The defaults is 0.
Examples
--------
>>> x = np.arange(9).reshape((3,3))
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(np.diag(x))
array([[0, 0, 0],
[0, 4, 0],
[0, 0, 8]])
"""
v = asarray(v)
s = v.shape
if len(s)==1:
n = s[0]+abs(k)
res = zeros((n,n), v.dtype)
if (k>=0):
i = arange(0,n-k)
fi = i+k+i*n
else:
i = arange(0,n+k)
fi = i+(i-k)*n
res.flat[fi] = v
return res
elif len(s)==2:
N1,N2 = s
if k >= 0:
M = min(N1,N2-k)
i = arange(0,M)
fi = i+k+i*N2
else:
M = min(N1+k,N2)
i = arange(0,M)
fi = i + (i-k)*N2
return v.flat[fi]
else:
raise ValueError, "Input must be 1- or 2-d."
def visualizeTransMatrix(matrix, titleName, phonemesNetwork):
visualizeMatrix(matrix, titleName)
listPhonemeNames = []
for phoneme in phonemesNetwork:
listPhonemeNames.append(phoneme.ID)
from numpy.core.numeric import arange
plt.xticks(arange(len(listPhonemeNames)) , listPhonemeNames )
plt.yticks(arange(len(listPhonemeNames)) , listPhonemeNames )
plt.show()
def diagflat(v, k=0):
"""
Create a two-dimensional array with the flattened input as a diagonal.
Parameters
----------
v : array_like
Input data, which is flattened and set as the `k`-th
diagonal of the output.
k : int, optional
Diagonal to set. The default is 0.
Returns
-------
out : ndarray
The 2-D output array.
See Also
--------
diag : Matlab workalike for 1-D and 2-D arrays.
diagonal : Return specified diagonals.
trace : Sum along diagonals.
Examples
--------
>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
"""
try:
wrap = v.__array_wrap__
except AttributeError:
wrap = None
v = asarray(v).ravel()
s = len(v)
n = s + abs(k)
res = zeros((n, n), v.dtype)
if (k >= 0):
i = arange(0, n - k)
fi = i + k + i * n
else:
i = arange(0, n + k)
fi = i + (i - k) * n
res.flat[fi] = v
if not wrap:
return res
return wrap(res)
def tri(N, M=None, k=0, dtype=float, *, like=None):
"""
An array with ones at and below the given diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
${ARRAY_FUNCTION_LIKE}
.. versionadded:: 1.20.0
Returns
-------
tri : ndarray of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> np.tri(3, 5, -1)
array([[0., 0., 0., 0., 0.],
[1., 0., 0., 0., 0.],
[1., 1., 0., 0., 0.]])
"""
if like is not None:
return _tri_with_like(N, M=M, k=k, dtype=dtype, like=like)
if M is None:
M = N
m = greater_equal.outer(arange(N, dtype=_min_int(0, N)),
arange(-k, M - k, dtype=_min_int(-k, M - k)))
# Avoid making a copy if the requested type is already bool
m = m.astype(dtype, copy=False)
return m
def plot1():
fig1 = plt.figure()
x = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005))
y = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005))
z = map(lambda x: x + gauss(0,0.005), arange(-1,1,0.005))
line = array(zip(x,y,z))
lpc = LPCImpl(h = 0.05, mult = 2, scaled = False)
lpc_curve = lpc.lpc(X=line)
ax = Axes3D(fig1)
ax.set_title('testNoisyLine1')
curve = lpc_curve[0]['save_xd']
ax.scatter(curve[:,0],curve[:,1],curve[:,2],c = 'red')
return fig1
def linspace(start, stop, num=50, endpoint=True, retstep=False):
"""Return evenly spaced numbers.
Return num evenly spaced samples from start to stop. If
endpoint is True, the last sample is stop. If retstep is
True then return (seq, step_value), where step_value used.
:Parameters:
start : {float}
The value the sequence starts at.
stop : {float}
The value the sequence stops at. If ``endpoint`` is false, then
this is not included in the sequence. Otherwise it is
guaranteed to be the last value.
num : {integer}
Number of samples to generate. Default is 50.
endpoint : {boolean}
If true, ``stop`` is the last sample. Otherwise, it is not
included. Default is true.
retstep : {boolean}
If true, return ``(samples, step)``, where ``step`` is the
spacing used in generating the samples.
:Returns:
samples : {array}
``num`` equally spaced samples from the range [start, stop]
or [start, stop).
step : {float} (Only if ``retstep`` is true)
Size of spacing between samples.
:See Also:
`arange` : Similiar to linspace, however, when used with
a float endpoint, that endpoint may or may not be included.
`logspace`
"""
num = int(num)
if num <= 0:
return array([], float)
if endpoint:
if num == 1:
return array([float(start)])
step = (stop - start) / float((num - 1))
y = _nx.arange(0, num) * step + start
y[-1] = stop
else:
step = (stop - start) / float(num)
y = _nx.arange(0, num) * step + start
if retstep:
return y, step
else:
return y
def tri(N, M=None, k=0, dtype=float):
"""
An array with ones at and below the given diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
Returns
-------
tri : ndarray of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``i <= j + k``, 0 otherwise.
Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> np.tri(3, 5, -1)
array([[ 0., 0., 0., 0., 0.],
[ 1., 0., 0., 0., 0.],
[ 1., 1., 0., 0., 0.]])
"""
if M is None:
M = N
m = greater_equal.outer(arange(N, dtype=_min_int(0, N)),
arange(-k, M-k, dtype=_min_int(-k, M - k)))
# Avoid making a copy if the requested type is already bool
if np_dtype(dtype) != np_dtype(bool):
m = m.astype(dtype)
return m
def tri(N, M=None, k=0, dtype=float):
"""
An array with ones at and below the given diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
Returns
-------
tri : ndarray of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``i <= j + k``, 0 otherwise.
Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> np.tri(3, 5, -1)
array([[ 0., 0., 0., 0., 0.],
[ 1., 0., 0., 0., 0.],
[ 1., 1., 0., 0., 0.]])
"""
if M is None:
M = N
m = greater_equal.outer(arange(N), arange(-k, M - k))
# Avoid making a copy if the requested type is already bool
if np_dtype(dtype) != np_dtype(bool):
m = m.astype(dtype)
return m
def polyint(p, m=1, k=None):
"""Return the mth analytical integral of the polynomial p.
If k is None, then zero-valued constants of integration are used.
otherwise, k should be a list of length m (or a scalar if m=1) to
represent the constants of integration to use for each integration
(starting with k[0])
"""
m = int(m)
if m < 0:
raise ValueError, "Order of integral must be positive (see polyder)"
if k is None:
k = NX.zeros(m, float)
k = atleast_1d(k)
if len(k) == 1 and m > 1:
k = k[0]*NX.ones(m, float)
if len(k) < m:
raise ValueError, \
"k must be a scalar or a rank-1 array of length 1 or >m."
if m == 0:
return p
else:
truepoly = isinstance(p, poly1d)
p = NX.asarray(p)
y = NX.zeros(len(p)+1, float)
y[:-1] = p*1.0/NX.arange(len(p), 0, -1)
y[-1] = k[0]
val = polyint(y, m-1, k=k[1:])
if truepoly:
val = poly1d(val)
return val
def helixHeteroscedasticCrossingDemo():
#Parameterise a helix (no noise)
fig5 = plt.figure()
t = arange(-1,1,0.001)
x = map(lambda x: x + gauss(0,0.01 + 0.05*sin(8*pi*x)), (1 - t*t)*sin(4*pi*t))
y = map(lambda x: x + gauss(0,0.01 + 0.05*sin(8*pi*x)), (1 - t*t)*cos(4*pi*t))
z = map(lambda x: x + gauss(0,0.01 + 0.05*sin(8*pi*x)), t)
line = array(zip(x,y,z))
lpc = LPCImpl(h = 0.15, t0 = 0.1, mult = 2, it = 500, scaled = False)
lpc_curve = lpc.lpc(line)
ax = Axes3D(fig5)
ax.set_title('helixHeteroscedasticWithCrossing')
curve = lpc_curve[0]['save_xd']
ax.scatter(x,y,z, c = 'red')
ax.plot(curve[:,0],curve[:,1],curve[:,2])
saveToPdf(fig5, '/tmp/helixHeteroscedasticWithCrossing.pdf')
lpc.set_in_dict('cross', False, '_lpcParameters')
fig6 = plt.figure()
lpc_curve = lpc.lpc(X=line)
ax = Axes3D(fig6)
ax.set_title('helixHeteroscedasticWithoutCrossing')
curve = lpc_curve[0]['save_xd']
ax.scatter(x,y,z, c = 'red')
ax.plot(curve[:,0],curve[:,1],curve[:,2])
saveToPdf(fig6, '/tmp/helixHeteroscedasticWithoutCrossing.pdf')
def twoDisjointLinesWithMSClustering():
t = arange(-1,1,0.002)
x = map(lambda x: x + gauss(0,0.02)*(1-x*x), t)
y = map(lambda x: x + gauss(0,0.02)*(1-x*x), t)
z = map(lambda x: x + gauss(0,0.02)*(1-x*x), t)
line1 = array(zip(x,y,z))
line = vstack((line1, line1 + 3))
lpc = LPCImpl(start_points_generator = lpcMeanShift(ms_h = 1), h = 0.05, mult = None, it = 200, cross = False, scaled = False, convergence_at = 0.001)
lpc_curve = lpc.lpc(X=line)
#Plot results
fig = plt.figure()
ax = Axes3D(fig)
labels = lpc._startPointsGenerator._meanShift.labels_
labels_unique = unique(labels)
cluster_centers = lpc._startPointsGenerator._meanShift.cluster_centers_
n_clusters = len(labels_unique)
colors = cycle('bgrcmyk')
for k, col in zip(range(n_clusters), colors):
cluster_members = labels == k
cluster_center = cluster_centers[k]
ax.scatter(line[cluster_members, 0], line[cluster_members, 1], line[cluster_members, 2], c = col, alpha = 0.1)
ax.scatter([cluster_center[0]], [cluster_center[1]], [cluster_center[2]], c = 'b', marker= '^')
curve = lpc_curve[k]['save_xd']
ax.plot(curve[:,0],curve[:,1],curve[:,2], c = col, linewidth = 3)
plt.show()
def create_dataset():
dataset = SupervisedDataSet(1, 1)
for x in arange(0, 4*pi, pi/30):
dataset.addSample(x, sin(x))
return dataset
def checkLinearConsistence(self):
'''
This method checks and fixes the correct proportion between the meshes of each edge.
'''
for edge in self.GraphEdgeToMesh.iterkeys():
if edge.Side =='venous':
meshes = self.GraphEdgeToMesh[edge]
startingMesh = meshes[0]
startingRadius = self.ElementIdsToElements[str(startingMesh.keys()[0])].Radius[0]
endingMesh = meshes[len(meshes)-1]
endingRadius = self.ElementIdsToElements[str(endingMesh.keys()[0])].Radius[len(self.ElementIdsToElements[str(endingMesh.keys()[0])].Radius)-1]
elLen = edge.Length['value']/len(meshes)
self.dz = elLen/1.0e5
z = arange(0.0,elLen,self.dz)
dr = (endingRadius-startingRadius)/(len(meshes))
for mesh in meshes:
if mesh == startingMesh:
r1 = startingRadius
r2 = r1+dr
elif mesh == endingMesh:
r1 = r2
r2 = endingRadius
else:
r1 = r2
r2+=dr
r_z = r1+((dr/elLen)*z)
self.ElementIdsToElements[str(mesh.keys()[0])].Radius = r_z
def showAverageQValues(p, v, nEpisodes, path):
'''Colorplot for the average QValues'''
lrAgent = loadEpisodeVar(p, v, 0, path, 'lrAgent')
ny, nx = shape(lrAgent.x)
avgValues = zeros((ny, nx))
for e in xrange(nEpisodes):
if e != 0: lrAgent = loadEpisodeVar(p, v, e, path, 'lrAgent')
avgValues += lrAgent.x
# pdb.set_trace()
avgValues = avgValues / nEpisodes
figure()
title('Average Q-values over the trials- p=' + str(p) + ' v=' + str(v))
dlbd = lrAgent.lbd[1] - lrAgent.lbd[0]
last = lrAgent.lbd[-1] + dlbd
X = r_[
lrAgent.lbd,
last] #watch out with this limit here "last" (pcolor doesn't show the last column)
Y = arange(ny + 1)
Z = avgValues
pcolor(X, Y, Z)
colorbar()
axis([lrAgent.lbd[0], last, 0, ny + 1])
xlabel('Learning rates')
ylabel('Trials')
def calcTheoreticalLWCProfile(cloudTop,cloudBase,zInc,betaStatic,cloudBaseTemp,lowestMeasuredLWC,lowestMeasuredAlt,omega):
LWCs = []
alts = []
Zs = []
logZs = []
deltaZ = cloudTop - cloudBase # Absolute Wolkendicke
# Ermittelung der Grenzschichten zwischen den 3 Layern:
boundary1 = 0. # Höhe der Grenze zwischen Layer1 und Layer2 (untere und mittlere Schicht)
boundary2 = 0. # Höhe der Grenze zwischen Layer2 und Layer3 (mittlere und obere Schicht)
if deltaZ >= 166.67: boundary1 = deltaZ * 0.3 + cloudBase # boundary1 entspricht 30% der Nebeldicke
else: boundary1 = 50. + cloudBase # boundary1 entspricht 50m über Nebeluntergrenze
if deltaZ >= 500.00: boundary2 = cloudTop - 75. # boundary2 entspricht 75m unter Nebelobergrenze
else: boundary2 = cloudTop - deltaZ * 0.15 # boundary2 entspricht 15% von der Gesamtdicke unter Nebelobergrenze = 85% der Nebeldicke
# Anpassung von beta (Eq. 4.44):
beta = betaStatic * cloudTop / 1000.
# Bestimmung des LWC-Wertes bei 0m Höhe
# Annahme: Zwischen Boden und niedrigstem LWC-Messpunkt ist der LWC-Gradient subadiabatisch mit beta = betaStatic
l_LWC_adiab = adiabaticLWC(-lowestMeasuredAlt,cloudBaseTemp)
l_LWC = (1-beta) * l_LWC_adiab + lowestMeasuredLWC
# Inkrementieren durch das Profil:
for alt in arange(cloudBase,cloudTop+zInc,zInc):
# Festlegen von Variablen (u.a. betaCurrent) je nach Schicht:
betaCurrent = 0.
# Wenn wir uns im unteren Layer befinden:
if alt <= boundary1:
betaCurrent = beta * ((alt - cloudBase) / (boundary1 - cloudBase))
LWC_adiab = adiabaticLWC(alt-cloudBase,cloudBaseTemp)
LWC = (1-betaCurrent) * LWC_adiab + l_LWC # Eq. 4.43 (ohne Weg über mixing ratio), + l_LWC für Rechtsverschiebung
# Wenn wir uns im mittleren Layer befinden:
if (alt <= boundary2) and (alt > boundary1):
betaCurrent = beta
LWC_adiab = adiabaticLWC(alt-cloudBase,cloudBaseTemp)
LWC = (1-betaCurrent) * LWC_adiab + l_LWC # Eq. 4.43 (ohne Weg über mixing ratio), + l_LWC für Rechtsverschiebung
# Wenn wir uns im oberen Layer befinden:
if alt > boundary2:
# Hier soll der LWC einfach nur linear abnehmen. D.h. es wird eine Gerade gebildet zwischen
# 0 (Obergrenze) und LWC-Wert @ boundary2 und für die jeweilige Höhe der entsprechende Wert berechnet:
LWC = (alt-cloudTop) / ((boundary2 - cloudTop) / ((1-beta) * adiabaticLWC(boundary2-cloudBase,cloudBaseTemp) + l_LWC)) # + l_LWC für Rechtsverschiebung
Z = LWC/omega
if Z>0:
logZ = 10*(math.log10(Z))
else:
logZ = -999.
LWCs.append(LWC)
Zs.append(Z)
alts.append(alt)
logZs.append(logZ)
finalList = zip(alts,LWCs,Zs,logZs)
return finalList
def plot_price_volume(buy_prices, buy_volumes, sell_prices, sell_volumes, show_intersections=False):
intersect_x = None
intersect_y = None
for i in range(0, len(buy_prices)):
x_buy = [r for r in buy_volumes[i]]
y_buy = [r for r in buy_prices[i]]
x_sell = [r for r in sell_volumes[i]]
y_sell = [r for r in sell_prices[i]]
f_buy = lambda x: interp(x, x_buy, y_buy)
f_sell = lambda x: interp(x, x_sell, y_sell)
if show_intersections == True:
intersect_x, intersect_y = get_intersection_point(x_buy, y_buy, x_sell, y_sell, time=str(times[i]))
plt.plot(intersect_x, intersect_y, 'ko')
plt.plot(x_buy, f_buy(x_buy), 'k-', label='Demand Curve')#, linewidth=0.2, markersize=0.1)
plt.plot(x_sell, f_sell(x_sell), 'k--', label='Supply Curve')
#plt.annotate(str(intersect_x[0])+ ' | ' + str(intersect_y[0]), xy=(intersect_x, intersect_y),
# xytext=(intersect_x-3000, intersect_y-100))
#plt.plot(41500, 80.16, 'ro')
plt.xlabel("MWh")
plt.ylabel("EUR/MWh")
plt.legend(loc='best')
plt.ylim(-200, 2000)
plt.yticks(arange(-200, 2000, 200.0))
plt.grid(axis='y')
plt.autoscale()
plt.show()
def diag_indices(n, ndim=2):
"""Return the indices to access the main diagonal of an array.
This returns a tuple of indices that can be used to access the main
diagonal of an array with ndim (>=2) dimensions and shape (n,n,...,n). For
ndim=2 this is the usual diagonal, for ndim>2 this is the set of indices
to access A[i,i,...,i] for i=[0..n-1].
Parameters
----------
n : int
The size, along each dimension, of the arrays for which the returned
indices can be used.
ndim : int, optional
The number of dimensions.
Notes
-----
.. versionadded:: 1.4.0
See also
--------
diag_indices_from
Examples
--------
Create a set of indices to access the diagonal of a (4,4) array:
>>> di = diag_indices(4)
>>> a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
>>> a
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> a[di] = 100
>>> a
array([[100, 2, 3, 4],
[ 5, 100, 7, 8],
[ 9, 10, 100, 12],
[ 13, 14, 15, 100]])
Now, we create indices to manipulate a 3-d array:
>>> d3 = diag_indices(2,3)
And use it to set the diagonal of a zeros array to 1:
>>> a = zeros((2,2,2),int)
>>> a[d3] = 1
>>> a
array([[[1, 0],
[0, 0]],
[[0, 0],
[0, 1]]])
"""
idx = arange(n)
return (idx, ) * ndim
def diag_indices(n, ndim=2):
"""Return the indices to access the main diagonal of an array.
This returns a tuple of indices that can be used to access the main
diagonal of an array with ndim (>=2) dimensions and shape (n,n,...,n). For
ndim=2 this is the usual diagonal, for ndim>2 this is the set of indices
to access A[i,i,...,i] for i=[0..n-1].
Parameters
----------
n : int
The size, along each dimension, of the arrays for which the returned
indices can be used.
ndim : int, optional
The number of dimensions.
Notes
-----
.. versionadded:: 1.4.0
See also
--------
diag_indices_from
Examples
--------
Create a set of indices to access the diagonal of a (4,4) array:
>>> di = diag_indices(4)
>>> a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
>>> a
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> a[di] = 100
>>> a
array([[100, 2, 3, 4],
[ 5, 100, 7, 8],
[ 9, 10, 100, 12],
[ 13, 14, 15, 100]])
Now, we create indices to manipulate a 3-d array:
>>> d3 = diag_indices(2,3)
And use it to set the diagonal of a zeros array to 1:
>>> a = zeros((2,2,2),int)
>>> a[d3] = 1
>>> a
array([[[1, 0],
[0, 0]],
[[0, 0],
[0, 1]]])
"""
idx = arange(n)
return (idx,) * ndim
def kaiser(M, beta):
"""kaiser(M, beta) returns a Kaiser window of length M with shape parameter
beta.
"""
from numpy.dual import i0
n = arange(0, M)
alpha = (M - 1) / 2.0
return i0(beta * sqrt(1 - ((n - alpha) / alpha)**2.0)) / i0(beta)
def kaiser(M,beta):
"""kaiser(M, beta) returns a Kaiser window of length M with shape parameter
beta.
"""
from numpy.dual import i0
n = arange(0,M)
alpha = (M-1)/2.0
return i0(beta * sqrt(1-((n-alpha)/alpha)**2.0))/i0(beta)
def test_an_example_a(self):
a = arange(15).reshape(3,5)
self.assertEqual(a.shape, (3,5))
self.assertEqual(a.ndim, 2)
self.assertEqual(a.dtype.name, 'int64')
self.assertEqual(a.itemsize, 8) # 64/8
self.assertEqual(a.size, 15)
self.assertEqual(type(a), numpy.ndarray)
def __init__(self, agent):
self.agent = agent
self.lbdAllowed = zeros(self.agent.nLr, int)
self.ngbhdSize = 2
self.banThreshold = 8
self.banNumber = 20
self.sigma = 0.25**2
self.neighborhood = arange(2 * self.ngbhdSize + 1)
def GetTaoFromQ(self, el):
'''
Computing wall shear stress in terms of the flow rate,
using inverse womersley method of Cezeaux et al.1997
'''
self.radius = mean(el.Radius)
self.Res = el.R
self.length = el.Length
self.Name = el.Name
#WOMERSLEY NUMBER
self.alpha = self.radius * sqrt(
(2.0 * pi * self.density) / (self.tPeriod * self.viscosity))
#FOURIER SIGNAL
k = len(self.signal)
n = 0
while n < (self.nHarmonics):
An = 0
Bn = 0
for i in arange(k):
An += self.signal[i] * cos(
n * (2.0 * pi / self.tPeriod) * self.dt * self.nSteps[i])
Bn += self.signal[i] * sin(
n * (2.0 * pi / self.tPeriod) * self.dt * self.nSteps[i])
An = An * (2.0 / k)
Bn = Bn * (2.0 / k)
self.fourierModes.append(complex(An, Bn))
n += 1
self.Steps = linspace(0, self.tPeriod, self.samples)
self.WssSignal = []
self.Tauplot = []
for step in self.Steps:
self.tao = -self.fourierModes[0].real * 2.0
k = 1
while k < self.nHarmonics:
cI = complex(0., 1.)
cA = (self.alpha * pow((1.0 * k), 0.5)) * pow(cI, 1.5)
c1 = 2.0 * jn(1, cA)
c0 = cA * jn(0, cA)
cT = complex(0, -2.0 * pi * k * self.t / self.tPeriod)
'''tao computation'''
taoNum = self.alpha**2 * cI**3 * jn(1, cA)
taoDen = c0 - c1
taoFract = taoNum / taoDen
cTao = self.fourierModes[k] * exp(cT) * taoFract
self.tao += cTao.real
k += 1
self.tao *= -(self.viscosity / (self.radius**3 * pi))
self.Tauplot.append(self.tao * 10) #dynes/cm2
self.WssSignal.append(self.tao)
self.t += self.dtPlot
return self.WssSignal #Pascal
def hamming(M):
"""hamming(M) returns the M-point Hamming window.
"""
if M < 1:
return array([])
if M == 1:
return ones(1,float)
n = arange(0,M)
return 0.54-0.46*cos(2.0*pi*n/(M-1))
def SetFlowSignal(self, el, flowsig):
'''
Setting Flow Signal for specific mesh
'''
for sig in flowsig:
self.signal.append(float(sig)) #flow in m3/s
self.nSteps = arange(0, len(self.signal), 1)
self.dt = self.tPeriod / (len(self.nSteps) - 1)
self.dtPlot = self.tPeriod / self.samples
def SetFlowSignal(self, el, flowsig):
'''
Setting Flow Signal for specific mesh
'''
for sig in flowsig:
self.signal.append(float(sig)) #flow in m3/s
self.nSteps = arange(0,len(self.signal),1)
self.dt = self.tPeriod/(len(self.nSteps)-1)
self.dtPlot = self.tPeriod/self.samples
def hamming(M):
"""hamming(M) returns the M-point Hamming window.
"""
if M < 1:
return array([])
if M == 1:
return ones(1, float)
n = arange(0, M)
return 0.54 - 0.46 * cos(2.0 * pi * n / (M - 1))
def bartlett(M):
"""bartlett(M) returns the M-point Bartlett window.
"""
if M < 1:
return array([])
if M == 1:
return ones(1, float)
n = arange(0,M)
return where(less_equal(n,(M-1)/2.0),2.0*n/(M-1),2.0-2.0*n/(M-1))
def __init__(self, *args, **kwds):
NumpyTestCase.__init__(self, *args, **kwds)
self.data = numeric.arange(25)
self.maskeddata = MaskedArray(self.data)
self.maskeddata[10] = masked
self.func_pairs = [
(MF.mov_average, MA.mean),
(MF.mov_median, mstats.mmedian),
((lambda x, span : MF.mov_stddev(x, span, bias=True)), MA.std)]
def blackman(M):
"""blackman(M) returns the M-point Blackman window.
"""
if M < 1:
return array([])
if M == 1:
return ones(1, float)
n = arange(0,M)
return 0.42-0.5*cos(2.0*pi*n/(M-1)) + 0.08*cos(4.0*pi*n/(M-1))
def diagflat(v, k=0):
try:
wrap = v.__array_wrap__
except AttributeError:
wrap = None
v = asarray(v).ravel()
s = len(v)
n = s + abs(k)
res = zeros((n, n), v.dtype)
if (k >= 0):
i = arange(0, n - k)
fi = i + k + i * n
else:
i = arange(0, n + k)
fi = i + (i - k) * n
res.flat[fi] = v
if not wrap:
return res
return wrap(res)
def eye(N, M=None, k=0, dtype=float):
"""
Return a 2-D array with ones on the diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the output.
M : int, optional
Number of columns in the output. If None, defaults to `N`.
k : int, optional
Index of the diagonal: 0 refers to the main diagonal, a positive value
refers to an upper diagonal, and a negative value to a lower diagonal.
dtype : dtype, optional
Data-type of the returned array.
Returns
-------
I : ndarray (N,M)
An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.
See Also
--------
diag : Return a diagonal 2-D array using a 1-D array specified by the user.
Examples
--------
>>> np.eye(2, dtype=int)
array([[1, 0],
[0, 1]])
>>> np.eye(3, k=1)
array([[ 0., 1., 0.],
[ 0., 0., 1.],
[ 0., 0., 0.]])
"""
if M is None: M = N
m = equal(subtract.outer(arange(N), arange(M)),-k)
if m.dtype != dtype:
m = m.astype(dtype)
return m
def tri(N, M=None, k=0, dtype=float):
"""
Construct an array filled with ones at and below the given diagonal.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
Returns
-------
T : (N,M) ndarray
Array with a lower triangle filled with ones, in other words
``T[i,j] == 1`` for ``i <= j + k``.
Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> np.tri(3, 5, -1)
array([[ 0., 0., 0., 0., 0.],
[ 1., 0., 0., 0., 0.],
[ 1., 1., 0., 0., 0.]])
"""
if M is None: M = N
m = greater_equal(subtract.outer(arange(N), arange(M)),-k)
return m.astype(dtype)
def mvpolyval1d(p, val, axis=0):
# ToDo: need to switch to Horner's method
# why would we ever need to do this?
truepoly = isinstance(p, poly2d)
p = NX.asarray(p)
o = p.shape[axis]
o = np.reshape(np.power(val,NX.arange(o, 0, -1)-1),(-1,1))
o = o if axis == 0 else o.T
p = p * o
y = np.sum(p,axis-1)
if truepoly:
y = poly1d(y)
return y
def linspace(start, stop, num=50, endpoint=True, retstep=False):
"""Return evenly spaced numbers.
Return num evenly spaced samples from start to stop. If
endpoint is True, the last sample is stop. If retstep is
True then return the step value used.
"""
num = int(num)
if num <= 0:
return array([], float)
if endpoint:
if num == 1:
return array([float(start)])
step = (stop-start)/float((num-1))
y = _nx.arange(0, num) * step + start
y[-1] = stop
else:
step = (stop-start)/float(num)
y = _nx.arange(0, num) * step + start
if retstep:
return y, step
else:
return y
def visualize_trans_probs(self, lyricsWithModels, fromFrame, toFrame,
from_phoneme, to_phoneme):
'''
forced alignment: considers only previous state in desicion
'''
lenObs = numpy.shape(self.B_map)[1]
tmpOnsetProbArray = numpy.zeros(
(to_phoneme - from_phoneme + 1, lenObs))
# viterbi loop
# for t in xrange(1,lenObs):
for t in xrange(fromFrame, toFrame):
self.logger.debug("at time {} out of {}".format(t, lenObs))
if ParametersAlgo.WITH_ORACLE_ONSETS == -1:
whichMatrix = -1 # last matrix with no onset
else:
# distance of how many frames from closest onset
onsetDist, _ = getDistFromEvent(self.noteOnsets, t)
whichMatrix = min(ParametersAlgo.ONSET_SIGMA_IN_FRAMES + 1,
onsetDist)
self.logger.debug("which Matrix: " + str(whichMatrix))
for j in xrange(from_phoneme, to_phoneme + 1):
if j > 0:
a = self.transMatrices[whichMatrix][j - 1, j]
tmpOnsetProbArray[j - from_phoneme,
t] = a # because of indexing
# visualizeMatrix(tmpOnsetProbArray, 'titleName')
matplotlib.rcParams['figure.figsize'] = (20, 8)
visualizeMatrix(tmpOnsetProbArray[:, fromFrame:toFrame], '')
###### add vertical legend names
statesNetworkNames = []
for i in range(from_phoneme, to_phoneme + 1):
stateWithDur = lyricsWithModels.statesNetwork[i]
stateWithDurPrev = lyricsWithModels.statesNetwork[i - 1]
statesNetworkNames.append("{} -> {}".format(
stateWithDurPrev.phoneme.ID, stateWithDur.phoneme.ID))
import matplotlib.pyplot as plt
from numpy.core.numeric import arange
plt.yticks(arange(len(statesNetworkNames)), statesNetworkNames)
plt.show()
def polyder(p, m=1):
"""Return the mth derivative of the polynomial p.
"""
m = int(m)
truepoly = isinstance(p, poly1d)
p = NX.asarray(p)
n = len(p)-1
y = p[:-1] * NX.arange(n, 0, -1)
if m < 0:
raise ValueError, "Order of derivative must be positive (see polyint)"
if m == 0:
return p
else:
val = polyder(y, m-1)
if truepoly:
val = poly1d(val)
return val
def hann(self, signal, half=False):
"""
Apply a Hann windowing on raw signal, before FFT.
"""
points = len(signal)
# Hanning from Herschel (half window)"""
# hann = 0.5 * (1.0 + cos ((PI*i) / channels))"""
if half:
iarr = num.arange(points) * math.pi / points
iarr = 0.5 + 0.5 * math.cos(iarr)
# Hanning from numpy (full window)"""
else:
iarr = np.hanning(points)
hann = signal * iarr
return hann
def boxplotProbabilities(prob,nv, lbdMean):
'''
DEFINITION: makes a boxplot of the mean (within an episode) learning rates for different probabilities and a given volatility
INPUTS:
prob: probabilities array
nv: given volatility (you have to know what the indexes in lbdMean mean in terms of volatility e.g. 1 would mean volatility .005 if the simulation was done with vol=[.001 .005])
TODO - think of a way of how not to depend on knowing beforehand of how the simulation was done
lbdMean: array with the mean chosen learning rate in an episode. lbdMean is indexed [p,v,e]
'''
l=[]
for p in xrange(len(prob)):
l.append(lbdMean[p,nv,:])
figure()
boxplot(l)
pylab.xticks(range(1,len(prob)+1), prob)
xlabel('Reward probability')
ylabel('Average learning rate lambda')
title('Average learning rates distributions for v='+str(vol[nv]))
plot(arange(0,5),'x')
def showQValues2(lrAgent, spFactor=1):
'''Colorplot for the QValues'''
figure()
title('Q-values over the trials')
dlbd = lrAgent.lbd[1] - lrAgent.lbd[0]
ny, nx = shape(lrAgent.x)
last = lrAgent.lbd[-1] + dlbd
X = r_[
lrAgent.lbd,
last] #watch out with this limit here "last" (pcolor doesn't show the last column)
Y = arange(ny / spFactor + 1)
sample = array([i % spFactor == 0 for i in xrange(ny)])
Z = lrAgent.x[sample]
pcolor(X, Y, Z)
colorbar()
axis([lrAgent.lbd[0], last, 0, ny / spFactor + 1])
xlabel('Learning rates')
ylabel('Trials')
def _make_along_axis_idx(arr_shape, indices, axis):
# compute dimensions to iterate over
if not _nx.issubdtype(indices.dtype, _nx.integer):
raise IndexError("`indices` must be an integer array")
if len(arr_shape) != indices.ndim:
raise ValueError("`indices` and `arr` must have the same number of dimensions")
shape_ones = (1,) * indices.ndim
dest_dims = list(range(axis)) + [None] + list(range(axis + 1, indices.ndim))
# build a fancy index, consisting of orthogonal aranges, with the
# requested index inserted at the right location
fancy_index = []
for dim, n in zip(dest_dims, arr_shape):
if dim is None:
fancy_index.append(indices)
else:
ind_shape = shape_ones[:dim] + (-1,) + shape_ones[dim + 1 :]
fancy_index.append(_nx.arange(n).reshape(ind_shape))
return tuple(fancy_index)
