我们从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]
