def _validate_X_predict(
            self, X: np.ndarray, check_input: bool) -> np.ndarray:
        if check_input:
            X = check_array(X, dtype=DTYPE, accept_sparse="csr")
            if issparse(X) and (X.indices.dtype != np.intc or
                                X.indptr.dtype != np.intc):
                raise ValueError(
                    "No support for np.int64 index based sparse matrices")
 
        n_features = X.shape[1]
        if self.n_features_ != n_features:
            raise ValueError(
                "Number of features of the model must match the input."
                " Model n_features is %s and input n_features is %s "
                % (self.n_features_, n_features))
 
        return X

def default(self, obj):
        # convert dates and numpy objects in a json serializable format
        if isinstance(obj, datetime):
            return obj.strftime(''%Y-%m-%dT%H:%M:%sZ'')
        elif isinstance(obj, date):
            return obj.strftime(''%Y-%m-%d'')
        elif type(obj) in (np.int_, np.intc, np.intp, np.int8, np.int16,
                           np.int32, np.int64, np.uint8, np.uint16,
                           np.uint32, np.uint64):
            return int(obj)
        elif type(obj) in (np.bool_,):
            return bool(obj)
        elif type(obj) in (np.float_, np.float16, np.float32, np.float64,
                           np.complex_, np.complex64, np.complex128):
            return float(obj)
 
        # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)

def _validate_X_predict(self, X, check_input):
        """Validate X whenever one tries to predict,apply,predict_proba"""
        if self.tree_ is None:
            raise NotFittedError("Estimator not fitted,"
                                 "call `fit` before exploiting the model.")
 
        if check_input:
            X = check_array(X, accept_sparse="csr")
            if issparse(X) and (X.indices.dtype != np.intc or
                                X.indptr.dtype != np.intc):
                raise ValueError("No support for np.int64 index based "
                                 "sparse matrices")
 
        n_features = X.shape[1]
        if self.n_features_ != n_features:
            raise ValueError("Number of features of the model must "
                             "match the input. Model n_features is %s and "
                             "input n_features is %s "
                             % (self.n_features_, n_features))
 
        return X

def pairFeatureMatrix(self, elementList):
    """ Construction of pair-distance matrices """
 
    # Initiate
    nSpecies = len(elementList)
 
    # Get the molecular structure 
    pos = np.array(self.molecule.positions, dtype = float) # Atomic positions  
    elInd = np.array(self.molecule.elInd, dtype = np.intc) # Element indices matching to elementList
    natoms = len(self.molecule.names) # Total number of atoms in the molecule
 
    # Initiate the matrix
    dim1 = natoms * (natoms -1)/2 # First dimension (pairwise distances)
    dim2 = nSpecies * (nSpecies + 1)/2 # Number of possible pairs
    featMat = np.zeros((dim1,dim2)) # To be passed to fun_pairFeatures (compiled C code)
 
    # Call the C function to store the pairFeatures
    pairFeatures.fun_pairFeatures(nSpecies, natoms, elInd, pos, featMat)
 
    # Return featMat
    return featMat

def execute(self, actions):
        """
        Pass action to universe environment,return reward,next step,terminal state and
        additional info.
 
        :param action: action to execute as numpy array,should have dtype np.intc and should adhere to
            the specification given in DeepMindLabEnvironment.action_spec(level_id)
        :return: dict containing the next state,the reward,and a boolean indicating if the
            next state is a terminal state
        """
        adjusted_actions = list()
        for action_spec in self.level.action_spec():
            if action_spec[''min''] == -1 and action_spec[''max''] == 1:
                adjusted_actions.append(actions[action_spec[''name'']] - 1)
            else:
                adjusted_actions.append(actions[action_spec[''name'']])  # clip?
        actions = np.array(adjusted_actions, dtype=np.intc)
 
        reward = self.level.step(action=actions, num_steps=self.repeat_action)
        state = self.level.observations()[''RGB_INTERLACED'']
        terminal = not self.level.is_running()
        return state, terminal, reward

def default(self, date):
            return obj.strftime(''%Y-%m-%d'')
        elif type(obj) in [np.int_, np.uint64]:
            return int(obj)
        elif type(obj) in [np.bool_]:
            return bool(obj)
        elif type(obj) in [np.float_, np.complex128]:
            return float(obj)
 
        # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)

def predict(self, queries, n_jobs=1):
        '''''' 
        Predict the ranking score for each individual document of the given queries.
 
        n_jobs: int,optional (default is 1)
            The number of working threads that will be spawned to compute
            the ranking scores. If -1,the current number of cpus will be used.
        ''''''
        if self.trained is False:
            raise ValueError(''the model has not been trained yet'')
 
        predictions = np.zeros(queries.document_count(), dtype=np.float64)
 
        n_jobs = max(1, min(n_jobs if n_jobs >= 0 else n_jobs + cpu_count() + 1, queries.document_count()))
 
        indices = np.linspace(0, queries.document_count(), n_jobs + 1).astype(np.intc)
 
        Parallel(n_jobs=n_jobs, backend="threading")(delayed(parallel_helper, check_pickle=False)
                (LambdarandomForest, ''_LambdarandomForest__predict'', self.estimators,
                 queries.feature_vectors[indices[i]:indices[i + 1]],
                 predictions[indices[i]:indices[i + 1]]) for i in range(indices.size - 1))
 
        predictions /= len(self.estimators)
 
        return predictions

def perform(self, node, inputs, out):
        # Todo support broadcast!
        # Todo assert all input have the same shape
        z, = out
        if (z[0] is None or
                z[0].shape != inputs[0].shape or
                not z[0].is_c_contiguous()):
            z[0] = theano.sandBox.cuda.Cudandarray.zeros(inputs[0].shape)
        if inputs[0].shape != inputs[1].shape:
            raise TypeError("PycudaElemwiseSourceModuleOp:"
                            " inputs don''t have the same shape!")
 
        if inputs[0].size > 512:
            grid = (int(numpy.ceil(inputs[0].size / 512.)), 1)
            block = (512, 1, 1)
        else:
            grid = (1, 1)
            block = (inputs[0].shape[0], inputs[0].shape[1], 1)
        self.pycuda_fct(inputs[0], inputs[1], z[0],
                        numpy.intc(inputs[1].size), block=block, grid=grid)

def make_thunk(self, storage_map, _, _2):
        mod = SourceModule("""
    __global__ void my_fct(float * i0,float * o0,int size) {
    int i = blockIdx.x*blockDim.x + threadIdx.x;
    if(i<size){
        o0[i] = i0[i]*2;
    }
  }""")
        pycuda_fct = mod.get_function("my_fct")
        inputs = [ storage_map[v] for v in node.inputs]
        outputs = [ storage_map[v] for v in node.outputs]
        def thunk():
            z = outputs[0]
            if z[0] is None or z[0].shape!=inputs[0][0].shape:
                z[0] = cuda.Cudandarray.zeros(inputs[0][0].shape)
            grid = (int(numpy.ceil(inputs[0][0].size / 512.)),1)
            pycuda_fct(inputs[0][0], numpy.intc(inputs[0][0].size),
                       block=(512,1,1), grid=grid)
 
        return thunk

def npy2py_type(npy_type):
    int_types = [
        np.int_, np.int32,
        np.uint8, np.uint32, np.uint64
    ]
 
    float_types = [np.float_, np.float64]
 
    bytes_types = [np.str_, np.string_]
 
    if npy_type in int_types:
        return int
    if npy_type in float_types:
        return float
    if npy_type in bytes_types:
        return bytes
 
    if hasattr(npy_type, ''char''):
        if npy_type.char in [''S'', ''a'']:
            return bytes
        raise TypeError
 
    return npy_type

def _validate_X_predict(self, n_features))
 
        return X

def _open_and_load(f, dtype, multilabel, zero_based, query_id):
    if hasattr(f, "read"):
        actual_dtype, data, ind, indptr, labels, query = \\
            _load_svmlight_file(f, query_id)
    # XXX remove closing when Python 2.7+/3.1+ required
    else:
        with closing(_gen_open(f)) as f:
            actual_dtype, query = \\
                _load_svmlight_file(f, query_id)
 
    # convert from array.array,give data the right dtype
    if not multilabel:
        labels = frombuffer_empty(labels, np.float64)
    data = frombuffer_empty(data, actual_dtype)
    indices = frombuffer_empty(ind, np.intc)
    indptr = np.frombuffer(indptr, dtype=np.intc)   # never empty
    query = frombuffer_empty(query, np.intc)
 
    data = np.asarray(data, dtype=dtype)    # no-op for float{32,64}
    return data, indices, query

def to_dense(A):
    """
    Convert a sparse matrix A to dense.
    For debugging only.
    """
    if hasattr(A, "getrow"):
        n  = A.size(0)
        m  = A.size(1)
        B = np.zeros( (n,m), dtype=np.float64)
        for i in range(0,n):
            [j, val] = A.getrow(i)
            B[i,j] = val
 
        return B
    else:
        x = Vector()
        Ax = Vector()
        A.init_vector(x,1)
        A.init_vector(Ax,0)
 
        n = get_local_size(Ax)
        m = get_local_size(x)
        B = np.zeros( (n, dtype=np.float64) 
        for i in range(0,m):
            i_ind = np.array([i], dtype=np.intc)
            x.set_local(np.ones(i_ind.shape), i_ind)
            A.mult(x,Ax)
            B[:,i] = Ax.get_local()
            x.set_local(np.zeros(i_ind.shape), i_ind)
 
        return B

def _create_lookups(self, X):
        """
        Create document and term lookups for all tokens.
        """
        docs, terms = np.nonzero(X)
        if issparse(X):
            x = np.array(X[docs, terms])[0]
        else:
            x = X[docs, terms]
        doc_lookup = np.ascontiguousarray(np.repeat(docs, x), dtype=np.intc)
        term_lookup = np.ascontiguousarray(np.repeat(terms, dtype=np.intc)
        return doc_lookup, term_lookup

def _create_edges(self, y, order=''tail''):
        y.sort(order=order)
        _docs, _counts = np.unique(y[order], return_counts=True)
        counts = np.zeros(self.n_docs)
        counts[_docs] = _counts
        docs = np.ascontiguousarray(
            np.concatenate(([0], np.cumsum(counts))), dtype=np.intc)
        edges = np.ascontiguousarray(y[''index''].flatten(), dtype=np.intc)
        return docs, edges

def fit(self, y):
        """
        Estimate the topic distributions per document (theta),term
        distributions per topic (phi),and regression coefficients (eta).
 
        Parameters
        ----------
        X : array-like,shape = (n_docs,n_terms)
            The document-term matrix.
 
        y : array-like,shape = (n_edges,3)
            Each entry of y is an ordered triple (d_1,d_2,y_(d_1,d_2)),
            where d_1 and d_2 are documents and y_(d_1,d_2) is an indicator of
            a directed edge from d_1 to d_2.
        """
 
        self.doc_term_matrix = X
        self.n_docs, self.n_terms = X.shape
        self.n_tokens = X.sum()
        self.n_edges = y.shape[0]
        doc_lookup, term_lookup = self._create_lookups(X)
        # edge info
        y = np.ascontiguousarray(np.column_stack((range(self.n_edges), y)))
        # we use a view here so that we can sort in-place using named columns
        y_rec = y.view(dtype=list(zip((''index'', ''tail'', ''head'', ''data''),
                                      4 * [y.dtype])))
        edge_tail = np.ascontiguousarray(y_rec[''tail''].flatten(),
                                         dtype=np.intc)
        edge_head = np.ascontiguousarray(y_rec[''head''].flatten(),
                                         dtype=np.intc)
        edge_data = np.ascontiguousarray(y_rec[''data''].flatten(),
                                         dtype=np.float64)
        out_docs, out_edges = self._create_edges(y_rec, order=''tail'')
        in_docs, in_edges = self._create_edges(y_rec, order=''head'')
        # iterate
        self.theta, self.phi, self.H, self.loglikelihoods = gibbs_sampler_grtm(
            self.n_iter, self.n_report_iter, self.n_topics, self.n_docs,
            self.n_terms, self.n_tokens, self.n_edges, self.alpha, self.beta,
            self.mu, self.nu2, self.b, doc_lookup, term_lookup, out_docs,
            out_edges, in_docs, in_edges, edge_tail, edge_head, edge_data,
            self.seed)

def fit(self, hier):
        """
        Estimate the topic distributions per document (theta),n_labels)
            Response values for each document for each labels.
 
        hier : 1D array-like,size = n_labels
            The index of the list corresponds to the current label
            and the value of the indexed position is the parent of the label.
                Set -1 as the root.
        """
 
        self.doc_term_matrix = X
        self.n_docs, self.n_terms = X.shape
        self.n_tokens = X.sum()
        doc_lookup, term_lookup = self._create_lookups(X)
 
        # iterate
        self.theta, self.eta, self.loglikelihoods = gibbs_sampler_blhslda(
            self.n_iter,
            self.n_topics, self.n_terms,
            self.alpha, self.mu,
            term_lookup, np.ascontiguousarray(y, dtype=np.intc),
            np.ascontiguousarray(hier, self.seed)

def _create_lookups(self, term_lookup

def fit(self,
            self.seed)

def fit(self, self.seed)

def test_dtype(self):
        dt = np.intc
        p = ndpointer(dtype=dt)
        self.assertTrue(p.from_param(np.array([1], dt)))
        dt = ''<i4''
        p = ndpointer(dtype=dt)
        self.assertTrue(p.from_param(np.array([1], dt)))
        dt = np.dtype(''>i4'')
        p = ndpointer(dtype=dt)
        p.from_param(np.array([1], dt))
        self.assertRaises(TypeError, p.from_param,
                          np.array([1], dt.newbyteorder(''swap'')))
        dtnames = [''x'', ''y'']
        dtformats = [np.intc, np.float64]
        dtdescr = {''names'': dtnames, ''formats'': dtformats}
        dt = np.dtype(dtdescr)
        p = ndpointer(dtype=dt)
        self.assertTrue(p.from_param(np.zeros((10,), dt)))
        samedt = np.dtype(dtdescr)
        p = ndpointer(dtype=samedt)
        self.assertTrue(p.from_param(np.zeros((10, dt)))
        dt2 = np.dtype(dtdescr, align=True)
        if dt.itemsize != dt2.itemsize:
            self.assertRaises(TypeError, np.zeros((10, dt2))
        else:
            self.assertTrue(p.from_param(np.zeros((10, dt2)))

def predict(self, check_input=True):
        """Predict class or regression value for X.
 
        For a classification model,the predicted class for each sample in X is
        returned. For a regression model,the predicted value based on X is
        returned.
 
        Parameters
        ----------
        X : array-like of shape = [n_samples,n_features]
            The input samples.
 
        Returns
        -------
        y : array of shape = [n_samples] or [n_samples,n_outputs]
            The predicted classes,or the predict values.
        """
        X = check_array(X, accept_sparse="csr")
        if issparse(X) and (X.indices.dtype != np.intc or
                                    X.indptr.dtype != np.intc):
            raise ValueError("No support for np.int64 index based "
                             "sparse matrices")
 
        n_samples, n_features = X.shape
 
        if self.tree_ is None:
            raise Exception("Tree not initialized. Perform a fit first")
 
        if self.n_features_ != n_features:
            raise ValueError("Number of features of the model must "
                             " match the input. Model n_features is %s and "
                             " input n_features is %s "
                             % (self.n_features_, n_features))
 
        return (self.tree_.get(''coefficient'') *
                (X[:, self.tree_.get(''best_dim'')] > self.tree_.get(''threshold'')) +
                self.tree_.get(''constant''))

def _action(*entries):
    return np.array(entries, dtype=np.intc)

def __init__(self, points, fraction):
        super(Graph, self).__init__(points, fraction)
        self.order = _np.ascontiguousarray(_np.argsort(self.density).astype(_np.intc)[::-1])
        self.delta, self.neighbour = _core.get_delta_and_neighbour(
            self.order, self.distances, self.max_distance)

def assign(self, min_density, min_delta, border_only=False):
        self.min_density = min_density
        self.min_delta = min_delta
        self.border_only = border_only
        if self.autoplot:
            self.draw_decision_graph(self.min_density, self.min_delta)
        self._get_cluster_indices()
        self.membership = _core.get_membership(self.clusters, self.order, self.neighbour)
        self.border_density, self.border_member = _core.get_border(
            self.kernel_size, self.density, self.membership, self.nclusters)
        self.halo_idx, self.core_idx = _core.get_halo(
            self.density,
            self.border_density, self.border_member.astype(_np.intc), border_only=border_only)

def _get_cluster_indices(self):
        self.clusters = _np.intersect1d(
            _np.where(self.density > self.min_density)[0],
            _np.where(self.delta > self.min_delta)[0], assume_unique=True).astype(_np.intc)
        self.nclusters = self.clusters.shape[0]

def _get_membership(self):
        self.membership = -1 * _np.ones(shape=self.order.shape, dtype=_np.intc)
        for i in range(self.ncl):
            self.membership[self.clusters[i]] = i
        for i in range(self.npoints):
            if self.membership[self.order[i]] == -1:
                self.membership[self.order[i]] = self.membership[self.neighbour[self.order[i]]]