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), err_msg=msg)
            assert_equal(np.bitwise_or(zeros, ones), err_msg=msg)
            assert_equal(np.bitwise_or(ones, err_msg=msg)
 
            assert_equal(np.bitwise_xor(zeros, err_msg=msg)
            assert_equal(np.bitwise_xor(zeros, err_msg=msg)
            assert_equal(np.bitwise_xor(ones, err_msg=msg)
 
            assert_equal(np.bitwise_and(zeros, err_msg=msg)
            assert_equal(np.bitwise_and(zeros, err_msg=msg)
            assert_equal(np.bitwise_and(ones, err_msg=msg)

def test_types(self):
        for dt in self.bitwise_types:
            zeros = np.array([0], 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, msg)
            assert_(np.bitwise_and(zeros, 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, 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]