This will remove and return the n'th data point (starting at 0) from
        all columns.

        Parameters
        ----------
        n       
            Index of data point to pop.
348133
def pop_data_point(self, n):
        

        # loop over the columns and pop the data
        popped = []
        for k in self.ckeys:

            # first convert to a list
            data = list(self.c(k))

            # pop the data
            popped.append(data.pop(n))

            # now set this column again
            self.insert_column(_n.array(data), k)

        return popped
313496
def delete_index(self, cardinality):
        
        DatabaseConnector.delete_index(self, cardinality)

        query = "DROP INDEX IF EXISTS idx_{0}_gram_varchar;".format(cardinality)
        self.execute_sql(query)
        query = "DROP INDEX IF EXISTS idx_{0}_gram_normalized_varchar;".format(
            cardinality)
        self.execute_sql(query)
        query = "DROP INDEX IF EXISTS idx_{0}_gram_lower_varchar;".format(
            cardinality)
        self.execute_sql(query)
        query = "DROP INDEX IF EXISTS idx_{0}_gram_lower_normalized_varchar;".\
            format(cardinality)
        self.execute_sql(query)
        for i in reversed(range(cardinality)):
            if i != 0:
                query = "DROP INDEX IF EXISTS idx_{0}_gram_{1}_lower;".format(
                    cardinality, i)
                self.execute_sql(query)
419456
def pop(self, n=None):
        """"""
        if self._popped:
            assert n is None
            return []
        self._popped = True

        envs = []
        for i, instance in enumerate(self.instances):
            env = remote.Remote(
                handle=self._handles[i],
                vnc_address='{}:{}'.format(instance.host, instance.vnc_port),
                vnc_password='openai',
                rewarder_address='{}:{}'.format(instance.host, instance.rewarder_port),
                rewarder_password='openai',
            )
            envs.append(env)
        return envs
1330884
def remove(self, index):
        
        data = self.data
        index = self._split(index)
        for j, c in enumerate(index):
            i = int(c) - 1
            if j + 1 == len(index):
                try:
                    del data[i]
                except IndexError:
                    raise NoItemError('.'.join(index))
            else:
                data = data[i][4]
142210
def pop(self):
        
        if not self.empty():
            val = self.stack[-1]
            del self.stack[-1]
            return val
49282
def clear(self):
        """"""
        self._points = _np.empty( (self.prealloc,self.dim) )
        self._slice_for_run_nr = []
        self.memleft = self.prealloc
900144
def removePoint(self, point, preserveCurve=False):
        
        if not isinstance(point, int):
            point = self.points.index(point)
        point = normalizers.normalizeIndex(point)
        if point >= self._len__points():
            raise ValueError("No point located at index %d." % point)
        preserveCurve = normalizers.normalizeBoolean(preserveCurve)
        self._removePoint(point, preserveCurve)
1137508
public void removePoint(int index) {
        int numKnots = x.length;
        if (numKnots <= 2)
            return;
        float[] nx = new float[numKnots - 1];
        float[] ny = new float[numKnots - 1];
        int j = 0;
        for (int i = 0; i < numKnots - 1; i++) {
            if (i == index)
                j++;
            nx[i] = x[j];
            ny[i] = y[j];
            j++;
        }
        x = nx;
        y = ny;
    }
1221629
public Datum<SparseArray> remove(int i) {
        Datum<SparseArray> datum = data.remove(i);

        n -= datum.x.size();
        for (SparseArray.Entry item : datum.x) {
            colSize[item.i]--;
        }
        
        return datum;
    }
81843
def remove(self, *args):
        

        key = self.get_storage_key(*args)
        pk = self.instance.pk.get()
        logger.debug("removing %s from index %s" % (pk, key))
        self.connection.srem(key, pk)
        self._deindexed_values.add(tuple(args))
304735
def reset_index(self, **kwargs):
        
        drop = kwargs.get("drop", False)
        new_index = pandas.RangeIndex(len(self.index))
        if not drop:
            if isinstance(self.index, pandas.MultiIndex):
                # TODO (devin-petersohn) ensure partitioning is properly aligned
                new_column_names = pandas.Index(self.index.names)
                new_columns = new_column_names.append(self.columns)
                index_data = pandas.DataFrame(list(zip(*self.index))).T
                result = self.data.from_pandas(index_data).concat(1, self.data)
                return self.__constructor__(result, new_index, new_columns)
            else:
                new_column_name = (
                    self.index.name
                    if self.index.name is not None
                    else "index"
                    if "index" not in self.columns
                    else "level_0"
                )
                new_columns = self.columns.insert(0, new_column_name)
                result = self.insert(0, new_column_name, self.index)
                return self.__constructor__(result.data, new_index, new_columns)
        else:
            # The copies here are to ensure that we do not give references to
            # this object for the purposes of updates.
            return self.__constructor__(
                self.data.copy(), new_index, self.columns.copy(), self._dtype_cache
            )
98794
def index(self, value, start=None, stop=None):
        
        if start is None:
            start = 0
        if stop is None:
            stop = len(self._col_list)
        return self._col_list.index(value, start, stop)
642773
def pop(self):
        
        if len(self.stack):
            popped = self.stack.pop()
            log.debug('pop: (%s)\n%s', Repr(popped), Repr(self.stack))
            return popped
        else:
            log.debug('stack empty, not-popped')
        return None
403522
def pop(self, n=None):
        """"""
        self.error_buffer.check()

        envs = []

        if n is None:
            while True:
                try:
                    envs += self.ready.get(block=False)
                except queue.Empty:
                    break
        else:
            sync_timeout = 10 * 60
            start = time.time()

            wait_time = 1
            while len(envs) < n:
                try:
                    extra_logger.info('[%s] Waiting for %d envs, currently at %d, sleeping for %d', self.label, n, len(envs), wait_time)
                    envs += self.ready.get(timeout=wait_time)
                except queue.Empty:
                    self.error_buffer.check()
                wait_time = min(wait_time * 2, 30)
                delta = time.time() - start
                if delta > sync_timeout:
                    raise FatalError("Waited %.0fs to obtain envs, timeout was %.0fs. (Obtained %d/%d envs.)" % (delta, sync_timeout, len(envs), n))

        return envs
618282
def remove_index(self, index):
        ''
        index_rm, single = convert_key_to_index(force_list(self.indices.keys()), index)
        if single:
            index_rm = [index_rm]

        index_new = [i for i in range(len(self.indices)) if i not in index_rm]

        if not index_new: # no index left
            self.clear(True)
            return

        names = mget_list(force_list(self.indices.keys()), index_new)
        items = [mget_list(i, index_new) for i in self.items()]
        self.clear(True)
        _MI_init(self, items, names)
43979
def drop_empty_records(x, axis=1):
    
    # load module
    import numpy as np
    # input args check
    if not isinstance(x, np.ndarray or np.matrix):
        raise ValueError("x is not a numpy.ndarray or numpy.matrix.")

    # index
    idx = np.logical_not(np.all(np.logical_or(
        np.isnan(x), np.isinf(x)), axis=axis))

    if axis is 1:
        return x[idx, :].copy()
    elif axis is 0:
        return x[:, idx].copy()
    else:
        raise ValueError("only 2-dimensional datasets are supported.")
1269848
def reset_index(self):
        
        new_columns = OrderedDict()

        new_index = default_index(_obtain_length(self._length, self._data))

        new_columns.update((name, Series(data.values, new_index, data.dtype, name))
                           for name, data in self.index._gather_data().items())

        # the data/columns
        new_columns.update((sr.name, Series(sr.values, new_index, sr.dtype, sr.name))
                           for sr in self._iter())

        return DataFrame(new_columns, new_index)