Python numpy.bitwise_not() 使用实例

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_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) 

Example 2

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) 

Example 3

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 

Example 4

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) 

Example 5

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, :] 

Example 6

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] 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注