The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def __init__(self, x0, P0, Q, R, cor, f, h):
self.Q = Q
self.R = R
self.cor = cor
self.fa = lambda col: f(col[0], col[2])
self.ha = lambda col: h(col[0], col[1])
Pxx = P0
Pxv = 0.
self.xa = np.array( ((x0,), (0.,), (0.,), (0.,)) )
self.Pa = np.array( ((Pxx, Pxv , 0. , 0. ),
(Pxv, self.R, 0. , 0. ),
(0. , 0. , self.Q , self.cor),
(0. , 0. , self.cor, self.R )) )
self.lastobservation = np.NAN
self.predictedobservation = np.NAN
self.innov = np.NAN
self.innovcov = np.NAN
self.gain = np.NAN
self.loglikelihood = 0.0 Example 2
def remask(self):
"""Reset the mask based on the seeded connected component.
"""
body = self.to_body()
if not body.is_seed_in_mask():
return False
new_mask_bin, bounds = body.get_seeded_component(CONFIG.postprocessing.closing_shape)
new_mask_bin = new_mask_bin.astype(np.bool)
mask_block = self.mask[map(slice, bounds[0], bounds[1])].copy()
# Clip any values not in the seeded connected component so that they
# cannot not generate moves when rechecking.
mask_block[~new_mask_bin] = np.clip(mask_block[~new_mask_bin], None, 0.9 * CONFIG.model.t_move)
self.mask[:] = np.NAN
self.mask[map(slice, bounds[0], bounds[1])] = mask_block
return True Example 3
def MA_RIBBON(df, ma_series):
ma_array = np.zeros([len(df), len(ma_series)])
ema_list = []
for idx, ma_len in enumerate(ma_series):
ema_i = EMA(df, n = ma_len, field = 'close')
ma_array[:, idx] = ema_i
ema_list.append(ema_i)
corr = np.empty([len(df)])
pval = np.empty([len(df)])
dist = np.empty([len(df)])
corr[:] = np.NAN
pval[:] = np.NAN
dist[:] = np.NAN
max_n = max(ma_series)
for idy in range(len(df)):
if idy >= max_n - 1:
corr[idy], pval[idy] = stats.spearmanr(ma_array[idy,:], range(len(ma_series), 0, -1))
dist[idy] = max(ma_array[idy,:]) - min(ma_array[idy,:])
corr_ts = pd.Series(corr*100, index = df.index, name = "MARIBBON_CORR")
pval_ts = pd.Series(pval*100, index = df.index, name = "MARIBBON_PVAL")
dist_ts = pd.Series(dist, index = df.index, name = "MARIBBON_DIST")
return pd.concat([corr_ts, pval_ts, dist_ts] + ema_list, join='outer', axis=1) Example 4
def read_csv(filename, skip_lines=0):
csvfile = file(filename, 'rb')
reader = csv.reader(csvfile)
data = np.empty(0, dtype=object)
last_count = np.NAN
for line in reader:
if skip_lines > 0:
skip_lines = skip_lines - 1
continue
if data.size > 0:
if len(line) != last_count:
raise Exception('unequal columes found')
data = np.c_[data, line]
last_count = len(line)
else:
data = np.array(line, dtype=object)
data = data.reshape(len(data), 1)
last_count = len(line)
csvfile.close()
return data.T Example 5
def clear_fit(self, **kwargs):
# if no pixel was provided the current pixel is updated
if 'pixel' not in kwargs.keys() or kwargs['pixel'] == -1:
px = self._focus[0]
else:
px = kwargs['pixel'][0]
# clear fit
self._fit_functions[px, :] = numpy.zeros(6)
self._fit_initial_parameters[px, :, :] = numpy.NAN
self._fit_optimized_parameters[px, :, :] = numpy.NAN
# emit signal
if 'emit' not in kwargs or kwargs['emit']:
self._app.fit_changed.emit(self._id)
# TODO: Flip for 1D Example 6
def clear_fit(self, **kwargs):
# if no pixel was provided the current pixel is updated
if 'pixel' not in kwargs.keys() or kwargs['pixel'] == -1:
px = self._focus[0]
py = self._focus[1]
else:
px = kwargs['pixel'][0]
py = kwargs['pixel'][1]
# clear fit
self._fit_functions[px, py, :] = numpy.zeros(6)
self._fit_initial_parameters[px, py, :, :] = numpy.NAN
self._fit_optimized_parameters[px, py, :, :] = numpy.NAN
# emit signal
if 'emit' not in kwargs or kwargs['emit']:
self._app.fit_changed.emit(self._id) Example 7
def rasterplot(ax,trange,tstart,tend,spikesOut,n_neurons,colors=['r','b'],\
size=2.5,marker='.',sort=False):
spikesPlot = []
for i in n_neurons:
spikesti = trange[spikesOut[:, i] > 0].ravel()
spikesti = spikesti[np.where((spikesti>tstart) & (spikesti<tend))]
if len(spikesti)==0: spikesPlot.append([np.NAN])
else: spikesPlot.append(spikesti)
if sort:
idxs = np.argsort(
[spikesPlot[i][0] for i in range(len(spikesPlot))] )
idxs = idxs[::-1] # reverse sorted in time to first spike
else: idxs = range(len(n_neurons))
for i,idx in enumerate(idxs):
ax.scatter(spikesPlot[idx],[i+1]*len(spikesPlot[idx]),\
marker=marker,s=size,\
facecolor=colors[i%2],lw=0,clip_on=False)
ax.set_ylim((1,len(n_neurons)))
ax.set_xlim((tstart,tend))
ax.get_xaxis().get_major_formatter().set_useOffset(False) Example 8
def get_read_reg_events(r_data, interval_start, num_bases):
r_means = nh.get_read_base_means(r_data)
if r_data.start > interval_start:
# handle reads that start in middle of region
start_overlap = interval_start + num_bases - r_data.start
# create region with nan values
region_means = np.empty(num_bases)
region_means[:] = np.NAN
region_means[-start_overlap:] = r_means[:start_overlap]
elif r_data.end < interval_start + num_bases:
# handle reads that end inside region
end_overlap = r_data.end - interval_start
# create region with nan values
region_means = np.empty(num_bases)
region_means[:] = np.NAN
region_means[:end_overlap] = r_means[-end_overlap:]
else:
skipped_bases = interval_start - r_data.start
region_means = r_means[
skipped_bases:skipped_bases + num_bases]
return region_means Example 9
def linkage(df, n_groups):
# create the distance matrix based on the forbenius norm: |A-B|_F where A is
# a 24 x N matrix with N the number of timeseries inside the dataframe df
# TODO: We can save have time as we only need the upper triangle once as the
# distance matrix is symmetric
if True:
Y = np.empty((n_groups, n_groups,))
Y[:] = np.NAN
for i in range(len(Y)):
for j in range(len(Y[i,:])):
A = df.loc[i+1].values
B = df.loc[j+1].values
#print('Computing distance of:{},{}'.format(i,j))
Y[i,j] = norm(A-B, ord='fro')
# condensed distance matrix as vector for linkage (upper triangle as a vector)
y = Y[np.triu_indices(n_groups, 1)]
# create linkage matrix with wards algorithm an euclidean norm
Z = hac.linkage(y, method='ward', metric='euclidean')
# R = hac.inconsistent(Z, d=10)
return Z Example 10
def fcluster(df, Z, n_groups, n_clusters):
"""
"""
# create flat cluster, i.e. maximal number of clusters...
T = hac.fcluster(Z, criterion='maxclust', depth=2, t=n_clusters)
# add cluster id to original dataframe
df['cluster_id'] = np.NAN
# group is either days (1-365) or weeks (1-52)
#for d in df.index.get_level_values('group').unique():
for g in range(1, n_groups+1):
# T[d-1] because df.index is e.g. 1-365 (d) and T= is 0...364
df.ix[g, 'cluster_id'] = T[g-1]
# add the cluster id to the index
df.set_index(['cluster_id'], append=True, inplace=True)
# set cluster id as first index level for easier looping through cluster_ids
df.index = df.index.swaplevel(0, 'cluster_id')
# just to have datetime at the last level of the multiindex df
df.index = df.index.swaplevel('datetime', 'group')
return df Example 11
def set_value(self, column, value):
if column not in self._columns:
if isinstance(value, str):
self._columns.update({
column: np.empty((1, len(self._df)), dtype="object")
})
self._columns[column][:] = ""
elif isinstance(value, bool):
self._columns.update({
column: np.empty((1, len(self._df)), dtype="bool")
})
self._columns[column][:] = False
else:
self._columns.update({
column: np.empty((1, len(self._df)))
})
self._columns[column][:] = np.NAN
self._columns[column][0, self._current_row_index] = value Example 12
def linkage(counts_table):
"""
Return the linkage disequilibrium (D) for an arbitrary number of
loci given their contingency table.
"""
probs_table = frequency_to_probability(counts_table)
marginal_probs = get_marginal_probabilities(probs_table)
if either_locus_not_detected(marginal_probs):
return np.NAN
exp_freqs = marginal_probs.prod(axis=0)[0]
observed = probs_table.flat[-1]
if observed == 0:
return np.NAN
return observed - exp_freqs Example 13
def generate(self):
self.__validate()
self.__generatenoises()
self.__generatejumps()
processcount = len(self.__data._processnames)
self.__data._processes = np.empty((self.__data._timecount, processcount))
self.__data._processes[:] = np.NAN
for time in range(self.__data._timecount):
for pi, (pn, pf) in enumerate(zip(self.__data._processnames, self.__processfuncs)):
self.__data._processes[time, pi] = pf(time, pn, self.__data)
return self.__data.copy() Example 14
def tonumpyarray(self, fill=None, symmetric=False):
import numpy as np
if fill is None: fill = np.NAN
res = np.empty((self.__dim, self.__dim))
idx = 0
for i in range(self.__dim):
for j in range(i+1):
res[i,j] = self._data[idx]
if symmetric: res[j,i] = res[i,j]
idx += 1
if not symmetric: res[i,i+1:self.__dim] = fill
return res Example 15
def tonumpyarray(self, fill=None, symmetric=False):
import numpy as np
if fill is None: fill = np.NAN
res = np.empty((self.__dim, self.__dim))
idx = 0
for i in range(self.__dim):
for j in range(i):
res[i,j] = self._data[idx]
if symmetric: res[j,i] = res[i,j]
idx += 1
res[i,i] = fill
if not symmetric: res[i,i+1:self.__dim] = fill
return res Example 16
def __init__(self, x0, P0, params):
self._params = params
self.x = x0
self.P = P0
self._constterm = self._params.meanlogvar * (1. - self._params.persistence)
self._cv = self._params.cor * self._params.voloflogvar
self._cv2 = self._cv * self._cv
self._p2 = self._params.persistence * self._params.persistence
self._v2 = self._params.voloflogvar * self._params.voloflogvar
self.predictedobservation = np.NAN
self.lastobservation = None
self.innov = np.NAN
self.innovcov = np.NAN
self.gain = np.NAN
self.loglikelihood = 0.0 Example 17
def _compose_alpha(img_in, img_layer, opacity: float=1.0):
"""
Calculate alpha composition ratio between two images.
"""
comp_alpha = np.minimum(img_in[:, :, 3], img_layer[:, :, 3]) * opacity
new_alpha = img_in[:, :, 3] + (1.0 - img_in[:, :, 3]) * comp_alpha
np.seterr(divide='ignore', invalid='ignore')
ratio = comp_alpha / new_alpha
ratio[ratio == np.NAN] = 0.0
return ratio Example 18
def check_binary_nan(self, name, xp, dtype):
a = xp.array([-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, 2],
dtype=dtype)
b = xp.array([numpy.NAN, numpy.NAN, 1, 0, numpy.NAN, -1, -2],
dtype=dtype)
return getattr(xp, name)(a, b) Example 19
def check_unary_nan(self, name, xp, dtype):
a = xp.array(
[-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, dtype('inf')],
dtype=dtype)
return (a,) Example 20
def check_binary_nan(self, name, xp, dtype):
a = xp.array([-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, 2],
dtype=dtype)
b = xp.array([numpy.NAN, numpy.NAN, 1, 0, numpy.NAN, -1, -2],
dtype=dtype)
return a, b Example 21
def check_unary_nan(self, name, xp, dtype):
a = xp.array(
[-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, numpy.inf],
dtype=dtype)
return getattr(xp, name)(a) Example 22
def fill_symbol_value(symbols, valsyms, vals, fill_value=np.NAN):
if valsyms.size == 0:
return np.tile(np.NAN, len(symbols))
values = np.tile(np.NAN, len(symbols)) if len(vals.shape) == 1 else np.tile(np.NAN, (len(symbols),vals.shape[1]))
symbol2pos = ustr.get_str2pos_dict(symbols)
for i in xrange(len(valsyms)):
try:
if len(vals.shape) == 1:
values[symbol2pos[valsyms[i]]] = vals[i]
else:
values[symbol2pos[valsyms[i]], :] = vals[i, :]
except Exception, e:
pass
values[np.isnan(values)] = fill_value
return values Example 23
def get_mat_ewma(tsmat, alpha):
# EWMA(t) = alpha * ts(t) + (1-alpha) * EWMA(t-1)
ewma = np.tile(np.NAN, tsmat.shape)
for i in xrange(1, tsmat.shape[0]):
init_selection = np.isnan(ewma[i-1, :])
ewma[i-1, init_selection] = tsmat[i-1, init_selection]
ewma[i, :] = alpha * tsmat[i, :] + (1-alpha) * ewma[i-1, :]
return ewma Example 24
def get_mat_movingstd(tsmat, periods):
mstd = np.empty(shape = tsmat.shape)
mstd.fill(np.NAN)
for i in xrange(tsmat.shape[0]):
j = i - periods + 1
if j < 0:
j = 0
mstd[i,:] = np.nanstd(tsmat[j:i+1,:], 0)
return mstd Example 25
def get_mat_ma(tsmat, periods):
ma = np.empty(shape = tsmat.shape)
ma.fill(np.NAN)
for i in xrange(tsmat.shape[0]):
j = i - periods + 1
if j < 0:
j = 0
ma[i,:] = np.nanmean(tsmat[j:i+1,:], 0)
return ma Example 26
def get_array_ma(ts, periods):
ma = np.empty(shape = len(ts))
ma.fill(np.NAN)
for i in xrange(len(ts)):
j = i - periods + 1
if j < 0:
j = 0
ma[i] = np.nanmean(ts[j:i+1], 0)
return ma
# 0 for add, 1 for multiply Example 27
def ret2value(returns):
values = np.empty(shape=len(returns) + 1)
values.fill(np.NAN)
values[0] = 1
for i in xrange(len(returns)):
values[i + 1] = values[i] * (1 + returns[i])
return values Example 28
def retmat2valuemat(retmat):
valuemat = np.tile(np.NAN, (retmat.shape[0] + 1, retmat.shape[1]))
for i in xrange(retmat.shape[1]):
valuemat[:, i] = ret2value(retmat[:, i])
return valuemat Example 29
def value2ret(values):
if len(values.shape) == 1:
prevalues = np.append(np.NAN, values[0:-1])
returns = (values - prevalues) / prevalues
returns[np.isinf(returns)] = np.NAN
else:
prevalues = np.r_[
np.tile(np.NAN, (1, values.shape[1])), values[0:-1, :]]
returns = (values - prevalues) / prevalues
returns[np.isinf(returns)] = np.NAN
return returns Example 30
def get_bstrs_pos_in_astrs(astrs, bstrs, astrs2pos={}):
if not astrs2pos:
astrs2pos = get_str2pos_dict(astrs)
pos = np.zeros(shape=len(bstrs))
count = 0
for s in bstrs:
try:
pos[count] = astrs2pos[s]
except Exception:
pos[count] = np.NAN
count += 1
return pos Example 31
def check_binary_nan(self, name, xp, dtype):
a = xp.array([-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, 2],
dtype=dtype)
b = xp.array([numpy.NAN, numpy.NAN, 1, 0, numpy.NAN, -1, -2],
dtype=dtype)
return getattr(xp, name)(a, b) Example 32
def check_unary_nan(self, name, xp, dtype):
a = xp.array(
[-3, numpy.NAN, -1, numpy.NAN, 0, numpy.NAN, dtype('inf')],
dtype=dtype)
return getattr(xp, name)(a) Example 33
def _create_empty_variables(self): total_gap_size = self._get_total_length_of_all_gaps() self.new_df = pd.DataFrame(np.empty([self.orig_df.shape[0]+total_gap_size,self.orig_df.shape[1]])) self.new_df.iloc[:]=np.NAN self.new_time_stamps = [] self.new_i = 0
Example 34
def empty_np_array_with_size(self,rows,columns): np_array = np.zeros((rows,columns)) np_array[:] = np.NAN return np_array
Example 35
def set_fit(self, fit_functions, fit_initial_parameters, fit_optimized_parameters, **kwargs):
# if no pixel was provided the current pixel is updated
if 'pixel' not in kwargs.keys() or kwargs['pixel'] == -1:
px = self._focus[0]
else:
px = kwargs['pixel'][0]
# clear the old fit data
self._fit_functions[px, :] = numpy.zeros(6)
self._fit_initial_parameters[px, :, :] = numpy.NAN
self._fit_optimized_parameters[px, :, :] = numpy.NAN
# set new fit data
i_parameter = 0
for i_peak in range(len(fit_functions)):
if fit_functions[i_peak] == 1:
self._fit_functions[px, i_peak] = 1
self._fit_initial_parameters[px, i_peak, :3] = fit_initial_parameters[i_parameter:i_parameter+3]
self._fit_initial_parameters[px, i_peak, 3] = 0
self._fit_optimized_parameters[px, i_peak, :3] = fit_optimized_parameters[i_parameter:i_parameter+3]
self._fit_optimized_parameters[px, i_peak, 3] = 0
i_parameter += 3
elif fit_functions[i_peak] == 2:
self._fit_functions[px, i_peak] = 2
self._fit_initial_parameters[px, i_peak, :3] = fit_initial_parameters[i_parameter:i_parameter+3]
self._fit_initial_parameters[px, i_peak, 3] = 0
self._fit_optimized_parameters[px, i_peak, :3] = fit_optimized_parameters[i_parameter:i_parameter+3]
self._fit_optimized_parameters[px, i_peak, 3] = 0
i_parameter += 3
elif fit_functions[i_peak] == 3:
self._fit_functions[px, i_peak] = 3
self._fit_initial_parameters[px, i_peak, :] = fit_initial_parameters[i_parameter:i_parameter+4]
self._fit_optimized_parameters[px, i_peak, :] = fit_optimized_parameters[i_parameter:i_parameter+4]
i_parameter += 4
# emit signal
if 'emit' not in kwargs or kwargs['emit']:
self._app.fit_changed.emit(self._id) Example 36
def set_fit(self, fit_functions, fit_initial_parameters, fit_optimized_parameters, **kwargs):
# if no pixel was provided the current pixel is updated
if 'pixel' not in kwargs.keys() or kwargs['pixel'] == -1:
px = self._focus[0]
py = self._focus[1]
else:
px = kwargs['pixel'][0]
py = kwargs['pixel'][1]
# clear the old fit data
self._fit_functions[px, py, :] = numpy.zeros(6)
self._fit_initial_parameters[px, py, :, :] = numpy.NAN
self._fit_optimized_parameters[px, py, :, :] = numpy.NAN
# set new fit data
i_parameter = 0
for i_peak in range(len(fit_functions)):
if fit_functions[i_peak] == 1:
self._fit_functions[px, py, i_peak] = 1
self._fit_initial_parameters[px, py, i_peak, :3] = fit_initial_parameters[i_parameter:i_parameter+3]
self._fit_initial_parameters[px, py, i_peak, 3] = 0
self._fit_optimized_parameters[px, py, i_peak, :3] = fit_optimized_parameters[i_parameter:i_parameter+3]
self._fit_optimized_parameters[px, py, i_peak, 3] = 0
i_parameter += 3
elif fit_functions[i_peak] == 2:
self._fit_functions[px, py, i_peak] = 2
self._fit_initial_parameters[px, py, i_peak, :3] = fit_initial_parameters[i_parameter:i_parameter+3]
self._fit_initial_parameters[px, py, i_peak, 3] = 0
self._fit_optimized_parameters[px, py, i_peak, :3] = fit_optimized_parameters[i_parameter:i_parameter+3]
self._fit_optimized_parameters[px, py, i_peak, 3] = 0
i_parameter += 3
elif fit_functions[i_peak] == 3:
self._fit_functions[px, py, i_peak] = 3
self._fit_initial_parameters[px, py, i_peak, :] = fit_initial_parameters[i_parameter:i_parameter+4]
self._fit_optimized_parameters[px, py, i_peak, :] = fit_optimized_parameters[i_parameter:i_parameter+4]
i_parameter += 4
# emit signal
if 'emit' not in kwargs or kwargs['emit']:
self._app.fit_changed.emit(self._id) Example 37
def _compose_alpha(img_in, img_layer, opacity):
"""
Calculate alpha composition ratio between two images.
"""
comp_alpha = np.minimum(img_in[:, :, 3], img_layer[:, :, 3])*opacity
new_alpha = img_in[:, :, 3] + (1.0 - img_in[:, :, 3])*comp_alpha
np.seterr(divide='ignore', invalid='ignore')
ratio = comp_alpha/new_alpha
ratio[ratio == np.NAN] = 0.0
return ratio Example 38
def process(self, obj_data):
'''
NaN's data from DataWrapper
@param obj_data: Input DataWrapper, which will be modified in place
'''
labels = self.labels
column_names = self.column_names
for label, data, err in obj_data.getIterator():
if (labels is None or label in labels) and \
(column_names is None or data.name in column_names):
index = data.index
if self.start is None:
start = index[0]
else:
start = self.start
if self.end is None:
end = index[-1]
else:
end = self.end
new_nans = np.empty(len(data[start:end]))
new_nans[:] = np.NAN
new_nans = pd.Series(new_nans, index=data[start:end].index)
data.loc[start:end] = new_nans Example 39
def calc_fishers_method(pos_pvals, offset):
pvals_np = np.empty(pos_pvals[-1][1] + 1)
pvals_np[:] = np.NAN
pvals_np[[list(zip(*pos_pvals)[1])]] = np.maximum(
zip(*pos_pvals)[0], nh.SMALLEST_PVAL)
fishers_pvals = [
_calc_fm_pval(pvals_np[pos - offset:pos + offset + 1])
if pos - offset >= 0 and
pos + offset + 1 <= pvals_np.shape[0] and
not np.any(np.isnan(pvals_np[pos - offset:pos + offset + 1])
) else 1.0
for _, pos, _, _ in pos_pvals]
return fishers_pvals Example 40
def test_single_point_nan(self):
"""Test behaviour for a single NaN grid cell."""
self.cube.data[0][0][6][7] = np.NAN
msg = "NaN detected in input cube data"
with self.assertRaisesRegexp(ValueError, msg):
neighbourhood_method = CircularNeighbourhood
NBHood(neighbourhood_method, self.RADIUS).process(self.cube) Example 41
def test_threshold_point_nan(self):
"""Test behaviour for a single NaN grid cell."""
# Need to copy the cube as we're adjusting the data.
self.cube.data[0][2][2] = np.NAN
msg = "NaN detected in input cube data"
plugin = Threshold(
2.0, fuzzy_factor=self.fuzzy_factor, below_thresh_ok=True)
with self.assertRaisesRegexp(ValueError, msg):
plugin.process(self.cube) Example 42
def make_corners(self):
x = self.x_t
y = self.y_t
dx_half = np.empty_like(x)
dy_half = np.empty_like(x)
dx_half[:, 1:] = (x[:, 1:] - x[:, 0:-1]) / 2.0
dy_half[1:, :] = (y[1:, :] - y[0:-1, :]) / 2.0
# Need to extend South
dy_half[0, 1:] = dy_half[1, 1:]
dx_half[0, 1:] = dx_half[1, 1:]
# and West
dy_half[:, 0] = dy_half[:, 1]
dx_half[:, 0] = dx_half[:, 1]
clon = np.empty((self.num_lat_points, self.num_lon_points, 4))
clon[:] = np.NAN
clon[:, :, 0] = x - dx_half
clon[:, :, 1] = x + dx_half
clon[:, :, 2] = x + dx_half
clon[:, :, 3] = x - dx_half
assert(not np.isnan(np.sum(clon)))
clat = np.empty((self.num_lat_points, self.num_lon_points, 4))
clat[:] = np.NAN
clat[:, :, 0] = y - dy_half
clat[:, :, 1] = y - dy_half
clat[:, :, 2] = y + dy_half
clat[:, :, 3] = y + dy_half
assert(not np.isnan(np.sum(clat)))
self.clon_t = clon
self.clat_t = clat Example 43
def calc_area_of_polygons(clons, clats):
"""
Calculate the area of lat-lon polygons.
We project sphere onto a flat surface using an equal area projection
and then calculate the area of flat polygon.
This is slow we should do some caching to avoid recomputing.
"""
areas = np.zeros(clons.shape[1:])
areas[:] = np.NAN
for j in range(areas.shape[0]):
for i in range(areas.shape[1]):
lats = clats[:, j, i]
lons = clons[:, j, i]
lat_centre = lats[0] + abs(lats[2] - lats[1]) / 2
lon_centre = lons[0] + abs(lons[1] - lons[0]) / 2
pa = pyproj.Proj(proj_str.format(lat_centre, lon_centre))
x, y = pa(lons, lats)
cop = {"type": "Polygon", "coordinates": [zip(x, y)]}
areas[j, i] = shape(cop).area
assert(np.sum(areas) is not np.NAN)
assert(np.min(areas) > 0)
return areas Example 44
def cell2val(matrix_list, index):
pos_index = 0
matpos = {}
for i in range(0,index):
for j in range(0,index):
if i <= j:
matpos[(i,j)] = pos_index
pos_index += 1
valmatrix = np.zeros(pos_index)
for matrix in matrix_list:
newvec = np.zeros(pos_index)
matrix_open = open(matrix)
for line in matrix_open:
bin1, bin2, raw, norm, chrom1, chrom2 = line.split()
# if chrom1 == chrom2: #Ignore intrachromosomal contacts for now; could also implement as a check to see how close bin1 and bin2 are
# norm = np.NAN
coord = (int(bin1), int(bin2))
pos = matpos[coord]
if bin1 == bin2 or raw == 0:
newvec[pos] = 0 #set to which value you want to compute cors for (root normalized coverage, or raw coverage)
else:
newvec[pos] = log10(float(raw))
valmatrix = np.vstack((valmatrix, newvec))
matrix_open.close()
valmatrix = np.delete(valmatrix, 0, 0)
return valmatrix Example 45
def _init_pane(self):
nan = np.array([np.NAN, np.NAN])
X = np.column_stack([nan] * len(self.legend))
Y = np.column_stack([nan] * len(self.legend))
return self.viz.line(
X=X, Y=Y, env=self.env, opts=self.opts) Example 46
def make_corners(self):
# Uses double density grid to figure out corners.
x = self.x_vt
y = self.y_vt
# Corners of t points. Index 0 is bottom left and then
# anti-clockwise.
clon = np.empty((self.x_t.shape[0], self.x_t.shape[1], 4))
clon[:] = np.NAN
clon[:,:,0] = x[0:-1:2,0:-1:2]
clon[:,:,1] = x[0:-1:2,2::2]
clon[:,:,2] = x[2::2,2::2]
clon[:,:,3] = x[2::2,0:-1:2]
assert(not np.isnan(np.sum(clon)))
clat = np.empty((self.x_t.shape[0], self.x_t.shape[1], 4))
clat[:] = np.NAN
clat[:,:,0] = y[0:-1:2,0:-1:2]
clat[:,:,1] = y[0:-1:2,2::2]
clat[:,:,2] = y[2::2,2::2]
clat[:,:,3] = y[2::2,0:-1:2]
assert(not np.isnan(np.sum(clat)))
self.clon_t = clon
self.clat_t = clat Example 47
def make_corners(self):
x = self.x_t
y = self.y_t
dx_half = self.dx / 2.0
dy_half = self.dy / 2.0
# Set grid corners, we do these one corner at a time. Start at the
# bottom left and go anti-clockwise. This is the SCRIP convention.
clon = np.empty((self.num_lat_points, self.num_lon_points, 4))
clon[:] = np.NAN
clon[:,:,0] = x - dx_half
clon[:,:,1] = x + dx_half
clon[:,:,2] = x + dx_half
clon[:,:,3] = x - dx_half
assert(not np.isnan(np.sum(clon)))
clat = np.empty((self.num_lat_points, self.num_lon_points, 4))
clat[:] = np.NAN
clat[:,:,0] = y - dy_half
clat[:,:,1] = y - dy_half
clat[:,:,2] = y + dy_half
clat[:,:,3] = y + dy_half
assert(not np.isnan(np.sum(clat)))
# The bottom latitude band should always be Southern extent.
assert(np.all(clat[0, :, 0] == np.min(y) - dy_half))
assert(np.all(clat[0, :, 1] == np.min(y) - dy_half))
# The top latitude band should always be Northern extent.
assert(np.all(clat[-1, :, 2] == np.max(y) + dy_half))
assert(np.all(clat[-1, :, 3] == np.max(y) + dy_half))
self.clon_t = clon
self.clat_t = clat Example 48
def __mask_plot_data__(self, arr):
#tmp = self.Data.variables[key][:].ravel()FIGURE_FILENAME_TEMPLATE = 'qa-cab_pres_temp_%s_r%.2i_%s.png
#arr.ravel()[self.Index] = np.NAN
arr[self.Index] = np.NAN
return arr Example 49
def cosegregation(counts_table):
"""
Return the co-segregation frequency of n loci given their
contingency table.
"""
probs_table = frequency_to_probability(counts_table)
if either_locus_not_detected(probs_table):
return np.NAN
return probs_table.flat[-1] Example 50
def expected(counts_table):
"""
Return the expected co-segregation probability of an arbitrary number
of loci given their contingency table.
"""
probs_table = frequency_to_probability(counts_table)
marginal_probs = get_marginal_probabilities(probs_table)
if either_locus_not_detected(marginal_probs):
return np.NAN
exp_freqs = marginal_probs.prod(axis=0)[0]
return exp_freqs 