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 test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 2
def graphlet_kernel(graphs, num_samples): N = len(graphs) Phi = np.zeros((N,2**15)) P = generate_permutation_matrix() for i in range(len(graphs)): n = graphs[i].number_of_nodes() if n >= 6: A = nx.to_numpy_matrix(graphs[i]) A = np.asarray(A, dtype=np.uint8) for j in range(num_samples): r = np.random.permutation(n) window = A[np.ix_(r[:6],r[:6])] Phi[i, graphlet_type(window)] += 1 Phi[i,:] /= num_samples K = np.dot(Phi,np.dot(P,np.transpose(Phi))) return K
Example 3
def MakeEquationSystem_volumeControl_extendedFP(w_lst_tmstp, wTip, EltChannel, EltTip, C, dt, Q, ElemArea):
Ccc = C[np.ix_(EltChannel, EltChannel)]
Cct = C[np.ix_(EltChannel, EltTip)]
A = np.hstack((Ccc,-np.ones((EltChannel.size,1),dtype=np.float64)))
A = np.vstack((A, np.ones((1, EltChannel.size + 1), dtype=np.float64)))
A[-1,-1] = 0
S = -np.dot(Ccc,w_lst_tmstp[EltChannel]) - np.dot(Cct,wTip)
S = np.append(S,Q * dt / ElemArea - (sum(wTip)-sum(w_lst_tmstp[EltTip])))
return A, S
#----------------------------------------------------------------------------------------------------------------------- Example 4
def jw_number_restrict_operator(operator, n_electrons, n_qubits=None):
"""Restrict a Jordan-Wigner encoded operator to a given particle number
Args:
sparse_operator(ndarray or sparse): Numpy operator acting on
the space of n_qubits.
n_electrons(int): Number of particles to restrict the operator to
n_qubits(int): Number of qubits defining the total state
Returns:
new_operator(ndarray or sparse): Numpy operator restricted to
acting on states with the same particle number.
"""
if n_qubits is None:
n_qubits = int(numpy.log2(operator.shape[0]))
select_indices = jw_number_indices(n_electrons, n_qubits)
return operator[numpy.ix_(select_indices, select_indices)] Example 5
def _M2_sparse_sym(Xvar, mask_X, Yvar, mask_Y, weights=None):
""" 2nd self-symmetric moment matrix exploiting zero input columns
Computes X'X + Y'Y and X'Y + Y'X
"""
assert len(mask_X) == len(mask_Y), 'X and Y need to have equal sizes for symmetrization'
Cxxyy = np.zeros((len(mask_X), len(mask_Y)))
Cxxyy[np.ix_(mask_X, mask_X)] = _M2_dense(Xvar, Xvar, weights=weights)
Cxxyy[np.ix_(mask_Y, mask_Y)] += _M2_dense(Yvar, Yvar, weights=weights)
Cxyyx = np.zeros((len(mask_X), len(mask_Y)))
Cxy = _M2_dense(Xvar, Yvar, weights=weights)
Cyx = _M2_dense(Yvar, Xvar, weights=weights)
Cxyyx[np.ix_(mask_X, mask_Y)] = Cxy
Cxyyx[np.ix_(mask_Y, mask_X)] += Cyx
return Cxxyy, Cxyyx Example 6
def test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 7
def test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 8
def _cartesian_product(*arrays):
"""
Get the cartesian product of a number of arrays.
Parameters
----------
arrays : Iterable[np.ndarray]
The arrays to get a cartesian product of. Always sorted with respect
to the original array.
Returns
-------
out : np.ndarray
The overall cartesian product of all the input arrays.
"""
broadcastable = np.ix_(*arrays)
broadcasted = np.broadcast_arrays(*broadcastable)
rows, cols = np.prod(broadcasted[0].shape), len(broadcasted)
dtype = np.result_type(*arrays)
out = np.empty(rows * cols, dtype=dtype)
start, end = 0, rows
for a in broadcasted:
out[start:end] = a.reshape(-1)
start, end = end, end + rows
return out.reshape(cols, rows) Example 9
def test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 10
def _find_motif(self, data, row_indices):
"""Finds the largest xMOTIF (this is the direct implementation of the
pseucode of the FindMotif() procedure described in the original paper).
"""
num_rows, num_cols = data.shape
best_motif = Bicluster([], [])
seeds = np.random.choice(num_cols, self.num_seeds, replace=False)
for s in seeds:
seed_col = data[row_indices, s][:, np.newaxis]
for i in range(self.num_sets):
cols_set = np.random.choice(num_cols, self.set_size, replace=False)
rows_comp_data = seed_col == data[np.ix_(row_indices, cols_set)]
selected_rows = np.array([y for x, y in enumerate(row_indices) if np.all(rows_comp_data[x])], np.int)
seed_values = data[selected_rows, s][:, np.newaxis]
cols_comp_data = seed_values == data[selected_rows]
selected_cols = np.array([k for k in range(num_cols) if np.all(cols_comp_data[:, k])])
if len(selected_cols) >= self.alpha * num_cols and len(selected_rows) > len(best_motif.rows):
best_motif = Bicluster(selected_rows, selected_cols)
return best_motif Example 11
def _find_constrained_bicluster(self, data):
"""Find a k x l bicluster."""
num_rows, num_cols = data.shape
k = random.randint(1, math.ceil(num_rows / 2))
l = random.randint(1, math.ceil(num_cols / 2))
cols = np.random.choice(num_cols, size=l, replace=False)
old_avg, avg = float('-inf'), 0.0
while abs(avg - old_avg) > self.tol:
old_avg = avg
row_sums = np.sum(data[:, cols], axis=1)
rows = bn.argpartition(row_sums, num_rows - k)[-k:] # this is usually faster than rows = np.argsort(row_sums)[-k:]
col_sums = np.sum(data[rows, :], axis=0)
cols = bn.argpartition(col_sums, num_cols - l)[-l:] # this is usually faster than cols = np.argsort(col_sums)[-l:]
avg = np.mean(data[np.ix_(rows, cols)])
return Bicluster(rows, cols) Example 12
def compute_activity_matrix(self, xywrap, thwrap, wdim, pcw):
"""Compute the activation of pose cells. Taken from Renato de Pontes Pereira"""
# The goal is to return an update matrix that can be added/subtracted
# from the posecell matrix
pca_new = np.zeros([PC_DIM_XY, PC_DIM_XY, PC_DIM_TH])
# for nonzero posecell values
indices = np.nonzero(self.posecells)
for i,j,k in itertools.izip(*indices):
pca_new[np.ix_(xywrap[i:i+wdim],
xywrap[j:j+wdim],
thwrap[k:k+wdim])] += self.posecells[i,j,k]*pcw
return pca_new Example 13
def test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 14
def section_by_index(array, index, axis=0):
"""
Take the slice of `array` indexed by entries of `index`
along the specified `axis`.
"""
# alternative `axisindex` implementation
# that avoids the index arithmetic
# uses `numpy` fancy indexing instead
# possible index values for each dimension represented
# as `numpy` arrays all having the shape of `index`
indices = np.ix_(*[np.arange(dim) for dim in index.shape])
# the slice is taken along `axis`
# except for the array `index` itself, the other indices
# do nothing except trigger `numpy` fancy indexing
fancy_index = indices[:axis] + (index,) + indices[axis:]
# result has the same shape as `index`
return array[fancy_index] Example 15
def get_element_type_subset_indices(self):
"""
It is currently required that the element of two matching atoms is the same.
This constructs indices to e.g. the carbon-carbon submatrix.
"""
# TODO: this is redundant if the elements does not have to match
unique_elements = np.unique(self.reactants_elements)
subset_indices = np.empty(unique_elements.size, dtype=object)
for i, element in enumerate(unique_elements):
rows = np.where(self.reactants_elements == element)[0]
cols = np.where(self.products_elements == element)[0]
subset_indices[i] = np.ix_(rows,cols)
return subset_indices Example 16
def test_large_fancy_indexing(self, level=rlevel):
# Large enough to fail on 64-bit.
nbits = np.dtype(np.intp).itemsize * 8
thesize = int((2**nbits)**(1.0/5.0)+1)
def dp():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)] = 0
def dp2():
n = 3
a = np.ones((n,)*5)
i = np.random.randint(0, n, size=thesize)
a[np.ix_(i, i, i, i, i)]
self.assertRaises(ValueError, dp)
self.assertRaises(ValueError, dp2) Example 17
def test_regression_1(self):
# Test empty inputs create ouputs of indexing type, gh-5804
# Test both lists and arrays
for func in (range, np.arange):
a, = np.ix_(func(0))
assert_equal(a.dtype, np.intp) Example 18
def test_shape_and_dtype(self):
sizes = (4, 5, 3, 2)
# Test both lists and arrays
for func in (range, np.arange):
arrays = np.ix_(*[func(sz) for sz in sizes])
for k, (a, sz) in enumerate(zip(arrays, sizes)):
assert_equal(a.shape[k], sz)
assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
assert_(np.issubdtype(a.dtype, int)) Example 19
def test_bool(self):
bool_a = [True, False, True, True]
int_a, = np.nonzero(bool_a)
assert_equal(np.ix_(bool_a)[0], int_a) Example 20
def test_1d_only(self):
idx2d = [[1, 2, 3], [4, 5, 6]]
assert_raises(ValueError, np.ix_, idx2d) Example 21
def _gaus_condition(self, xi):
if np.ma.count_masked(xi) == 0:
return xi
a = xi.mask
b = ~xi.mask
xb = xi[b].data
Laa = self.prec[np.ix_(a, a)]
Lab = self.prec[np.ix_(a, b)]
xfill = np.empty_like(xi)
xfill[b] = xb
xfill[a] = self.mean[a] - solve(Laa, Lab.dot(xb - self.mean[b]))
return xfill Example 22
def gacPathCondEntropy(IminuszW, cluster_i, cluster_j):
# Compute conditional complexity from the subpart of the weighted adjacency matrix
# Inputs:
# - IminuszW: the matrix (I - z*P)
# - cluster_i: index vector of cluster i
# - cluster_j: index vector of cluster j
# Output:
# - L_ij - the sum of conditional complexities of cluster i and j after merging.
# by Wei Zhang (wzhang009 at gmail.com), June, 8, 2011
num_i = np.size(cluster_i)
num_j = np.size(cluster_j)
# detecting cross elements (this check costs much and is unnecessary)
ijGroupIndex = np.append(cluster_i, cluster_j)
y_ij = np.zeros((num_i + num_j, 2)) # [y_i, y_j]
y_ij[:num_i, 0] = 1
y_ij[num_i:, 1] = 1
idx = np.ix_(ijGroupIndex, ijGroupIndex)
L_ij = scipy.linalg.inv(IminuszW[idx]).dot(y_ij)
L_ij = sum(L_ij[:num_i, 0]) / (num_i * num_i) + sum(L_ij[num_i:, 1]) / (num_j * num_j)
return L_ij Example 23
def reconstruct_original_mat(self, thresh, intracluster_weight=0):
"""
reconstruct a similarity matrix with size equals to the original one, from the reduced similarity matrix
:param thresh: a threshold parameter to prune the edges of the graph
:param intracluster_weight: the weight to assign at each connection generated by the expansion of a cluster
:return: the reconstructed graph
"""
reconstructed_mat = np.zeros((self.N, self.N))
r_nodes = self.classes > 0
reconstructed_mat[np.ix_(r_nodes, r_nodes)] = intracluster_weight
for r in range(2, self.k + 1):
r_nodes = self.classes == r
reconstructed_mat[np.ix_(r_nodes, r_nodes)] = intracluster_weight
for s in range(1, r):
if self.is_weighted:
cl_pair = WeightedClassesPair(self.sim_mat, self.adj_mat, self.classes, r, s, self.epsilon)
else:
cl_pair = ClassesPair(self.adj_mat, self.classes, r, s, self.epsilon)
s_nodes = self.classes == s
if cl_pair.bip_density > thresh:
reconstructed_mat[np.ix_(r_nodes, s_nodes)] = reconstructed_mat[np.ix_(s_nodes, r_nodes)] = cl_pair.bip_density
np.fill_diagonal(reconstructed_mat, 0.0)
return reconstructed_mat Example 24
def __init__(self, adj_mat, classes, r, s, epsilon):
self.r = r
self.s = s
self.index_map = np.where(classes == r)[0]
self.index_map = np.vstack((self.index_map, np.where(classes == s)[0]))
self.bip_adj_mat = adj_mat[np.ix_(self.index_map[0], self.index_map[1])]
self.n = self.bip_adj_mat.shape[0]
self.bip_avg_deg = self.bip_avg_degree()
self.bip_density = self.compute_bip_density()
self.epsilon = epsilon Example 25
def __init__(self, sim_mat, adj_mat, classes, r, s, epsilon):
self.r = r
self.s = s
self.index_map = np.where(classes == r)[0]
self.index_map = np.vstack((self.index_map, np.where(classes == s)[0]))
self.bip_sim_mat = sim_mat[np.ix_(self.index_map[0], self.index_map[1])]
self.bip_adj_mat = adj_mat[np.ix_(self.index_map[0], self.index_map[1])]
self.n = self.bip_sim_mat.shape[0]
self.bip_avg_deg = self.bip_avg_degree()
self.bip_density = self.compute_bip_density()
self.epsilon = epsilon Example 26
def bin_sizes(self):
sizes1 = np.cos(self.get_bin_left_edges(0)) - np.cos(self.get_bin_right_edges(0))
sizes2 = self.get_bin_widths(1)
return reduce(np.multiply, np.ix_(sizes1, sizes2)) Example 27
def bin_sizes(self):
sizes1 = (self.get_bin_right_edges(0) ** 3 - self.get_bin_left_edges(0) ** 3) / 3
sizes2 = np.cos(self.get_bin_left_edges(1)) - np.cos(self.get_bin_right_edges(1))
sizes3 = self.get_bin_widths(2)
# Hopefully correct
return reduce(np.multiply, np.ix_(sizes1, sizes2,sizes3))
#return np.outer(sizes, sizes2, self.get_bin_widths(2)) # Correct Example 28
def bin_sizes(self):
sizes1 = 0.5 * (self.get_bin_right_edges(0) ** 2 - self.get_bin_left_edges(0) ** 2)
sizes2 = self.get_bin_widths(1)
sizes3 = self.get_bin_widths(2)
return reduce(np.multiply, np.ix_(sizes1, sizes2, sizes3)) Example 29
def reduce_distmat(full_dist_mat,
gal_templateids,
probe_templateids,
reduce_type=ReduceType.MeanMin):
# Get unique template indices and there positions for keeping initial order
#gal_tuids,gal_tuind=np.unique(gal_templateids,return_index=True)
#probe_tuids,probe_tuind=np.unique(probe_templateids,return_index=True)
gal_tuids, gal_tuind = np.unique(
[str(x) for x in gal_templateids], return_index=True)
probe_tuids, probe_tuind = np.unique(
[str(x) for x in probe_templateids], return_index=True)
red_dist_mat = np.zeros((len(gal_tuids), len(probe_tuids)))
# Loop on gallery
for g, gtupos in enumerate(gal_tuind):
gutid = gal_templateids[gtupos]
gt_pos = np.where(gal_templateids == gutid)[0]
# Loop on probe
for p, ptupos in enumerate(probe_tuind):
putid = probe_templateids[ptupos]
pt_pos = np.where(probe_templateids == putid)[0]
# Get appropriate distance
#print g,p
dist_val = 0.0
# TO BE FIXED
if reduce_type == ReduceType.MeanMin:
dist_val = np.mean(np.min(full_dist_mat[np.ix_(gt_pos, pt_pos)]))
else:
dist_val = np.amin(full_dist_mat[np.ix_(gt_pos, pt_pos)])
red_dist_mat[g, p] = dist_val
return red_dist_mat, gal_tuind, probe_tuind Example 30
def test_regression_1(self):
# Test empty inputs create ouputs of indexing type, gh-5804
# Test both lists and arrays
for func in (range, np.arange):
a, = np.ix_(func(0))
assert_equal(a.dtype, np.intp) Example 31
def test_shape_and_dtype(self):
sizes = (4, 5, 3, 2)
# Test both lists and arrays
for func in (range, np.arange):
arrays = np.ix_(*[func(sz) for sz in sizes])
for k, (a, sz) in enumerate(zip(arrays, sizes)):
assert_equal(a.shape[k], sz)
assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
assert_(np.issubdtype(a.dtype, int)) Example 32
def test_bool(self):
bool_a = [True, False, True, True]
int_a, = np.nonzero(bool_a)
assert_equal(np.ix_(bool_a)[0], int_a) Example 33
def test_1d_only(self):
idx2d = [[1, 2, 3], [4, 5, 6]]
assert_raises(ValueError, np.ix_, idx2d) Example 34
def _compute_log_likelihood(self, X):
seq_len = X.shape[0]
n_states = self.n_components
n_dim = X.shape[1]
p = np.zeros((seq_len,n_states))
for i in range(seq_len):
miss = np.isnan(X[i])
p[i] = np.sum(miss * np.log(self.miss_probs_) + (1-miss) * np.log(1-self.miss_probs_), axis=1)
if not np.all(miss):
for state in range(n_states):
mean = self.means_[state][miss==0]
cov = self.covars_[state][np.ix_(miss==0,miss==0)]
p[i][state] = p[i][state] + np.log(multivariate_normal.pdf(X[i][miss==0],mean=mean,cov=cov))
return p Example 35
def split_data(self, X, y, i):
sub_dict = {}
unique_val = np.unique(X[:, i])
c = range(i) + range(i + 1, X.shape[1])
for val in unique_val:
indice = np.where(X[:, i] == val)[0]
# print indice.shape
sub_dict[val] = (X[np.ix_(indice, c)], y[indice])
return sub_dict # sub_data, sub_target Example 36
def _extract_pairwise(self, X, y, n, is_train=True):
if self.cache is not None and (n, True, is_train) in self.cache:
return self.cache[n, True, is_train]
if not hasattr(X, "shape"):
raise ValueError("Precomputed kernels or affinity matrices have "
"to be passed as arrays or sparse matrices.")
if X.shape[0] != X.shape[1]:
raise ValueError("X should be a square kernel matrix")
train, test = self.splits[n]
result = X[np.ix_(train if is_train else test, train)]
if self.cache is not None:
self.cache[n, True, is_train] = result
return result Example 37
def compute_new_medoid(self,cluster, distances):
mask = np.ones(distances.shape)
mask[np.ix_(cluster,cluster)] = 0.
cluster_distances = np.ma.masked_array(data=distances, mask=mask, fill_value=10e9)
costs = cluster_distances.sum(axis=1)
return costs.argmin(axis=0, fill_value=10e9) Example 38
def get_global_stiffness(self,msz):
pass
#~ ni, nj = self.get_nodes()
#~ self.keg = np.zeros((msz,msz))
#~ idx = np.ix_([ni.label, nj.label],[ni.label, nj.label])
#~ row = np.array([ni.label, ni.label, nj.label, nj.label])
#~ col = np.array([ni.label, nj.label, ni.label, nj.label])
#~ data = self.get_element_stiffness().reshape(-1)
#~ print data, row, col
#~ self.keg = csr_matrix((data, (row, col)), shape=(msz,msz)).toarray()
#~ return self.keg Example 39
def generate_permutation_matrix(): P = np.zeros((2**15,2**15),dtype=np.uint8) for a in range(2): for b in range(2): for c in range(2): for d in range(2): for e in range(2): for f in range(2): for g in range(2): for h in range(2): for i in range(2): for j in range(2): for k in range(2): for l in range(2): for m in range(2): for n in range(2): for o in range(2): A = np.array([[0,a,b,c,d,e],[a,0,f,g,h,i],[b,f,0,j,k,l],[c,g,j,0,m,n],[d,h,k,m,0,o],[e,i,l,n,o,0]]) perms = multiset_permutations(np.array(range(6),dtype=np.uint8)) Per = np.zeros((factorial(6),6),dtype=np.uint8) ind = 0 for permutation in perms: Per[ind,:] = permutation ind += 1 for p in range(factorial(6)): A_per = A[np.ix_(Per[p,:],Per[p,:])] P[graphlet_type(A), graphlet_type(A_per)] = 1 return P
Example 40
def MakeEquationSystem_mechLoading_sameFP(w_LoadedElts, EltCrack, EltLoaded, C):
C_Crack = C[np.ix_(EltCrack, EltCrack)]
A = np.hstack((C_Crack, -np.ones((EltCrack.size, 1), dtype=np.float64)))
A = np.vstack((A, np.zeros((1, EltCrack.size + 1), dtype=np.float64)))
A[-1, np.where(EltCrack == EltLoaded)[0]] = 1
S = np.zeros((EltCrack.size + 1), dtype=np.float64)
S[-1] = w_LoadedElts
return A, S
#----------------------------------------------------------------------------------------------------------------------- Example 41
def MakeEquationSystem_mechLoading_extendedFP(wTip, EltChannel, EltTip, C, EltLoaded, w_loaded):
Ccc = C[np.ix_(EltChannel, EltChannel)]
Cct = C[np.ix_(EltChannel, EltTip)]
A = np.hstack((Ccc, -np.ones((EltChannel.size, 1),dtype=np.float64)))
A = np.vstack((A,np.zeros((1,EltChannel.size+1),dtype=np.float64)))
A[-1, np.where(EltChannel == EltLoaded)[0]] = 1
S = - np.dot(Cct, wTip)
S = np.append(S, w_loaded)
return A, S
#----------------------------------------------------------------------------------------------------------------------- Example 42
def MakeEquationSystem_volumeControl_sameFP(w, EltCrack, C, dt, Q, ElemArea):
C_Crack = C[np.ix_(EltCrack, EltCrack)]
A = np.hstack((C_Crack,-np.ones((EltCrack.size,1),dtype=np.float64)))
A = np.vstack((A,np.ones((1,EltCrack.size+1),dtype=np.float64)))
A[-1,-1] = 0
S = -np.dot(C_Crack,w[EltCrack])
S = np.append(S,Q * dt / ElemArea)
return A, S
#----------------------------------------------------------------------------------------------------------------------- Example 43
def maybe_convert_ix(*args):
"""
We likely want to take the cross-product
"""
ixify = True
for arg in args:
if not isinstance(arg, (np.ndarray, list, ABCSeries, Index)):
ixify = False
if ixify:
return np.ix_(*args)
else:
return args Example 44
def fit(self, X):
"""Sample a training set.
Parameters
----------
X: array-like
training set to sample observations from.
Returns
----------
self: obj
fitted instance with stored sample.
"""
self.train_shape = X.shape
sample_idx = {}
for i in range(2):
dim_size = min(X.shape[i], self.size)
sample_idx[i] = permutation(X.shape[i])[:dim_size]
sample = X[ix_(sample_idx[0], sample_idx[1])]
self.sample_idx_ = sample_idx
self.sample_ = sample
return self Example 45
def is_train(self, X):
"""Check if an array is the training set.
Parameters
----------
X: array-like
training set to sample observations from.
Returns
----------
self: obj
fitted instance with stored sample.
"""
if not hasattr(self, "train_shape"):
raise NotFittedError("This IdTrain instance is not fitted yet.")
if not self._check_shape(X):
return False
idx = self.sample_idx_
try:
# Grab sample from `X`
sample = X[ix_(idx[0], idx[1])]
return array_equal(sample, self.sample_)
except IndexError:
# If index is out of bounds, X.shape < training_set.shape
# -> X is not the training set
return False Example 46
def _M2_sparse(Xvar, mask_X, Yvar, mask_Y, weights=None):
""" 2nd moment matrix exploiting zero input columns """
C = np.zeros((len(mask_X), len(mask_Y)))
C[np.ix_(mask_X, mask_Y)] = _M2_dense(Xvar, Yvar, weights=weights)
return C Example 47
def cartesian_product(arrays):
""" Returns Cartesian product of given arrays (x and y): cartesian_product([x,y]) """
broadcastable = np.ix_(*arrays)
broadcasted = np.broadcast_arrays(*broadcastable)
rows, cols = reduce(np.multiply, broadcasted[0].shape), len(broadcasted)
out = np.empty(rows * cols, dtype=broadcasted[0].dtype)
start, end = 0, rows
for a in broadcasted:
out[start:end] = a.reshape(-1)
start, end = end, end + rows
# Return value(s)
return out.reshape(cols, rows).T Example 48
def test_regression_1(self):
# Test empty inputs create ouputs of indexing type, gh-5804
# Test both lists and arrays
for func in (range, np.arange):
a, = np.ix_(func(0))
assert_equal(a.dtype, np.intp) Example 49
def test_shape_and_dtype(self):
sizes = (4, 5, 3, 2)
# Test both lists and arrays
for func in (range, np.arange):
arrays = np.ix_(*[func(sz) for sz in sizes])
for k, (a, sz) in enumerate(zip(arrays, sizes)):
assert_equal(a.shape[k], sz)
assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
assert_(np.issubdtype(a.dtype, int)) Example 50
def test_bool(self):
bool_a = [True, False, True, True]
int_a, = np.nonzero(bool_a)
assert_equal(np.ix_(bool_a)[0], int_a) 