Python numpy 模块，bitwise_not() 实例源码
我们从Python开源项目中，提取了以下6个代码示例，用于说明如何使用numpy.bitwise_not()。
def test_values(self):
for dt in self.bitwise_types:
zeros = np.array([0], dtype=dt)
ones = np.array([-1], dtype=dt)
msg = "dt = '%s'" % dt.char
assert_equal(np.bitwise_not(zeros), ones, err_msg=msg)
assert_equal(np.bitwise_not(ones), zeros, err_msg=msg)
assert_equal(np.bitwise_or(zeros, zeros), zeros, err_msg=msg)
assert_equal(np.bitwise_or(zeros, ones), ones, err_msg=msg)
assert_equal(np.bitwise_or(ones, zeros), ones, err_msg=msg)
assert_equal(np.bitwise_or(ones, ones), ones, err_msg=msg)
assert_equal(np.bitwise_xor(zeros, zeros), zeros, err_msg=msg)
assert_equal(np.bitwise_xor(zeros, ones), ones, err_msg=msg)
assert_equal(np.bitwise_xor(ones, zeros), ones, err_msg=msg)
assert_equal(np.bitwise_xor(ones, ones), zeros, err_msg=msg)
assert_equal(np.bitwise_and(zeros, zeros), zeros, err_msg=msg)
assert_equal(np.bitwise_and(zeros, ones), zeros, err_msg=msg)
assert_equal(np.bitwise_and(ones, zeros), zeros, err_msg=msg)
assert_equal(np.bitwise_and(ones, ones), ones, err_msg=msg)
def test_types(self):
for dt in self.bitwise_types:
zeros = np.array([0], dtype=dt)
ones = np.array([-1], dtype=dt)
msg = "dt = '%s'" % dt.char
assert_(np.bitwise_not(zeros).dtype == dt, msg)
assert_(np.bitwise_or(zeros, zeros).dtype == dt, msg)
assert_(np.bitwise_xor(zeros, zeros).dtype == dt, msg)
assert_(np.bitwise_and(zeros, zeros).dtype == dt, msg)
def _mask_trigs(events, mask):
"""Helper function for masking digital trigger values"""
if not isinstance(mask, int):
raise TypeError('You provided a(n) %s. Mask must be an int.'
% type(mask))
n_events = len(events)
if n_events == 0:
return events.copy()
mask = np.bitwise_not(mask)
events[:, 1:] = np.bitwise_and(events[:, 1:], mask)
events = events[events[:, 1] != events[:, 2]]
return events
def _numpy(self, data, weights, shape):
q = self.quantity(data)
self._checkNPQuantity(q, shape)
self._checkNPWeights(weights, shape)
weights = self._makeNPWeights(weights, shape)
newentries = weights.sum()
import numpy
selection = numpy.isnan(q)
numpy.bitwise_not(selection, selection)
subweights = weights.copy()
subweights[selection] = 0.0
self.nanflow._numpy(data, subweights, shape)
# switch to float here like in bin.py else numpy throws
# TypeError on trivial integer cases such as:
# >>> q = numpy.array([1,2,3,4])
# >>> np.divide(q,1,q)
# >>> np.floor(q,q)
q = numpy.array(q, dtype=numpy.float64)
neginfs = numpy.isneginf(q)
posinfs = numpy.isposinf(q)
numpy.subtract(q, self.origin, q)
numpy.divide(q, self.binWidth, q)
numpy.floor(q, q)
q = numpy.array(q, dtype=numpy.int64)
q[neginfs] = LONG_MINUSINF
q[posinfs] = LONG_PLUSINF
selected = q[weights > 0.0]
selection = numpy.empty(q.shape, dtype=numpy.bool)
for index in numpy.unique(selected):
if index != LONG_NAN:
bin = self.bins.get(index)
if bin is None:
bin = self.value.zero()
self.bins[index] = bin
numpy.not_equal(q, index, selection)
subweights[:] = weights
subweights[selection] = 0.0
bin._numpy(data, subweights, shape)
# no possibility of exception from here on out (for rollback)
self.entries += float(newentries)
def __init__(self, M, row_sparsity=None, column_sparsity=None, sparsity_threshold=0.05):
# pylint: disable=len-as-condition
self.M = M
self.num_rows, self.num_columns = M.shape
self.sparsity_threshold = sparsity_threshold*np.max(M.shape)
self.M_csr = sp.sparse.csr_matrix(M)
if row_sparsity is None:
self.elements_per_row = np.array([self.M_csr.indptr[i + 1] - self.M_csr.indptr[i] for i in range(0, len(self.M_csr.indptr) - 1)])
row_sparsity = self.elements_per_row < self.sparsity_threshold
if column_sparsity is None:
self.M_csc = sp.sparse.csc_matrix(M)
self.elements_per_column = np.array([self.M_csc.indptr[i + 1] - self.M_csc.indptr[i] for i in range(0, len(self.M_csc.indptr) - 1)])
column_sparsity = self.elements_per_column < self.sparsity_threshold
self.r_s = row_sparsity if len(row_sparsity) else np.array([True]*self.M.shape[0])
self.r_d = np.bitwise_not(self.r_s)
self.ri_s = self.r_s.nonzero()[0]
self.ri_d = self.r_d.nonzero()[0]
self.c_s = column_sparsity if len(column_sparsity) else np.array([True]*self.M.shape[1])
self.c_d = np.bitwise_not(self.c_s)
self.ci_s = self.c_s.nonzero()[0]
self.ci_d = self.c_d.nonzero()[0]
M_coo = sp.sparse.coo_matrix(M)
# sparse blocks s, and ss are created to be the size of the entire matrix, M. Dense blocks, however, are just the size of the subblocks.
self.block_s = mask_sparse_matrix_by_rows(M_coo, self.row_sparsity)
self.block_ss = mask_sparse_matrix_by_columns(self.block_s, self.column_sparsity).tocsr()
self.block_ss_csc = self.block_ss.tocsc()
self.block_sd = mask_sparse_matrix_by_columns(self.block_s, self.column_density).tocsr()[:, self.dense_column_indices].todense() if self.num_dense_columns else np.zeros((self.num_sparse_rows, self.num_dense_columns))
self.block_s = self.block_s.tocsr()
self.block_s_csc = self.block_s.tocsc()
self.block_d_sparse = mask_sparse_matrix_by_rows(M_coo, self.row_density).tocsr()
self.block_d = self.block_d_sparse[self.dense_row_indices, :].todense()
self.block_ds = self.block_d[:, self.sparse_column_indices]
self.block_dd = self.block_d[:, self.dense_column_indices]
self.sparse_block = self.block_ss_csc[:, self.sparse_column_indices].tocsr()[self.sparse_row_indices, :]
def get_demand_or_head_residual(self, head, demand):
if self.mode == 'PDD':
minP = self.minimum_pressures
nomP = self.nominal_pressures
j_d = self.junction_demand
m = self._slope_of_pdd_curve
delta = self._pdd_smoothing_delta
n_j = self.num_junctions
P = head[:n_j] - self.node_elevations[:n_j]
H = head[:n_j]
Dact = demand[:n_j]
self.demand_or_head_residual[:n_j] = (
self.isolated_junction_array * H + (1.0 - self.isolated_junction_array)*(
(P <= minP) * (Dact - j_d*m*(P-minP)) +
(P > minP) * (P <= (minP + delta)) * (
Dact - j_d*(
self.pdd_poly1_coeffs_a*P**3 +
self.pdd_poly1_coeffs_b*P**2 +
self.pdd_poly1_coeffs_c*P +
self.pdd_poly1_coeffs_d
)
) +
(P > (nomP - delta)) * (P <= nomP) * (
Dact - j_d*(
self.pdd_poly2_coeffs_a*P**3 +
self.pdd_poly2_coeffs_b*P**2 +
self.pdd_poly2_coeffs_c*P +
self.pdd_poly2_coeffs_d
)
) +
(P > nomP) * (Dact - j_d * (m*(P-nomP) + 1.0))
)
)
# for the last segment, assignment is required because 0*np.nan does not equal 0 (same with np.inf)
last_segment = (Dact - j_d*((P-minP)/(nomP-minP))**0.5)
last_segment[np.bitwise_not((P > (minP + delta))*(P <= (nomP - delta)))] = 0.0
self.demand_or_head_residual[:n_j] = (self.demand_or_head_residual[:n_j] +
last_segment*(1.0-self.isolated_junction_array))
else:
self.demand_or_head_residual[:self.num_junctions] = (
self.isolated_junction_array * head[:self.num_junctions] +
(1.0 - self.isolated_junction_array) * (demand[:self.num_junctions] - self.junction_demand)
)
for node_id in self._tank_ids:
self.demand_or_head_residual[node_id] = head[node_id] - self.tank_head[node_id]
for node_id in self._reservoir_ids:
self.demand_or_head_residual[node_id] = head[node_id] - self.reservoir_head[node_id]