Returns MultiIndex without any rows containing null values according to Baloo's convention.

        Returns
        -------
        MultiIndex
            MultiIndex with no null values.
183513
def dropna(self):
        
        not_nas = [v.notna() for v in self.values]
        and_filter = reduce(lambda x, y: x & y, not_nas)

        return self[and_filter]
881114
public int getValueIndex() {

        int result = 0;
        Node previousSibling = getElement().getPreviousSibling();
        while (previousSibling != null) {
            result++;
            previousSibling = previousSibling.getPreviousSibling();
        }
        return result;
    }
845901
public DataBuffer getIncludedIndices() {

        if (isScalar()) {
            return Nd4j.createBuffer(new int[] {0, 0});
        }

        List<Integer> ind = new ArrayList<>();

        for (int i = 0; i < values.length(); i++) {
            boolean isIn = true;
            int idxNotFixed = 0;
            int[] idx = getUnderlyingIndicesOf(i).asInt(); // TODO change for getIndicesOf(i)

            for (int dim = 0; dim < idx.length; dim++) {
                if (flags()[dim] == 1) {
                    if (sparseOffsets()[dim] != idx[dim]) {
                        isIn = false;
                        break;
                    }
                } else {
                    int lowerBound = sparseOffsets()[dim];
                    long upperBound = sparseOffsets()[dim] + shape()[idxNotFixed];
                    if (!(idx[dim] >= lowerBound && idx[dim] < upperBound)) {
                        isIn = false;
                        break;
                    }
                    idxNotFixed++;
                }
            }
            if (isIn) {
                int notFixedDim = 0;
                for (int dim = 0; dim < idx.length; dim++) {
                    if (flags()[dim] == 0) {
                        if (shape()[notFixedDim] == 1) {
                            ind.add(0);
                            notFixedDim++;
                        } else {
                            ind.add(idx[dim] - sparseOffsets()[dim]);
                        }
                    }
                }
            }
        }
        return Nd4j.createBuffer(Ints.toArray(ind));
    }
920031
public NegateMultiPos<S, Integer, Character> after(int leftIndex) {
		return new NegateMultiPos<S, Integer, Character>(leftIndex, null) {

			@Override protected S result() {
				return aQueue('K', left, right, pos, position, null, plusminus, filltgt);
			}
		};
	}
156142
def getIndicesFromBigIndex(self, bigIndex):
        
        indices = numpy.array([0 for i in range(self.ndims)])
        for i in range(self.ndims):
            indices[i] = bigIndex // self.dimProd[i] % self.dims[i]
        return indices
1251347
def rm_empty_indices(*args):
    
    rm_inds = args[0]

    if not rm_inds:
        return args[1:]

    keep_inds = [i for i in range(len(args[1])) if i not in rm_inds]

    return [[a[i] for i in keep_inds] for a in args[1:]]
897426
def rank(idx, dim):
    """"""
    idxm = multi_index(idx, dim)
    out = 0
    while idxm[-1:] == (0,):
        out += 1
        idxm = idxm[:-1]
    return out
981308
def get_indices(integers):
    
    indices = AccumDict(accum=[])  # idx -> [(start, stop), ...]
    start = 0
    for i, vals in itertools.groupby(integers):
        n = sum(1 for val in vals)
        indices[i].append((start, start + n))
        start += n
    return indices
618133
def GetIndex(self):
        '''
        '''
        if self.index is None:
            return None

        if self.index:
            res, ui = chmlib.chm_resolve_object(self.file, self.index)
            if (res != chmlib.CHM_RESOLVE_SUCCESS):
                return None

        size, text = chmlib.chm_retrieve_object(self.file, ui, 0l, ui.length)
        if (size == 0):
            sys.stderr.write('GetIndex: file size = 0\n')
            return None
        return text
48319
public NegateMultiPos<S, Integer, Integer> setBetns(int leftIndex, int rightIndex) {
		return new NegateMultiPos<S, Integer, Integer>(leftIndex, rightIndex) {

			@Override protected S result() {
				return delegateQueue('I', left, right, pos, position, null, plusminus, filltgt);
			}
		};
	}
284699
def _reindex_with_indexers(self, reindexers, fill_value=None, copy=False,
                               allow_dups=False):
        

        # reindex doing multiple operations on different axes if indicated
        new_data = self._data
        for axis in sorted(reindexers.keys()):
            index, indexer = reindexers[axis]
            baxis = self._get_block_manager_axis(axis)

            if index is None:
                continue

            index = ensure_index(index)
            if indexer is not None:
                indexer = ensure_int64(indexer)

            # TODO: speed up on homogeneous DataFrame objects
            new_data = new_data.reindex_indexer(index, indexer, axis=baxis,
                                                fill_value=fill_value,
                                                allow_dups=allow_dups,
                                                copy=copy)

        if copy and new_data is self._data:
            new_data = new_data.copy()

        return self._constructor(new_data).__finalize__(self)
1332674
def unchanged(self, thresh=0.05, idx=True):
        
        ind = (
            (self.data[self.pval_column] > thresh)
            | np.isnan(self.data[self.pval_column])
        )
        if idx:
            return ind
        return self[ind]
34975
function excludeIntIndices(intIdxVector, maxLen) {
  return jd.seq(maxLen).isIn(intIdxVector).not().which();
}
1291551
private int getConstraintIndex(int colIndex) {

        for (int i = 0; i < imColIndex.length; i++) {
            for (int j = 0; j < imColIndex[i].length; j++) {
                if (colIndex == imColIndex[i][j]) {
                    return i;
                }    // end of if (col == imColIndex[i][j])
            }        // end of for (int j=0; j<imColIndex[i].length; j++)
        }            // end of for (int i=0; i<imColIndex.length; i++)

        return -1;
    }
1224587
def getIndex(self, indexName, indexClass):
        """"""
        if indexClass == "vertex":
            try:
                return Index(indexName, indexClass, "manual",
                        self.neograph.nodes.indexes.get(indexName))
            except client.NotFoundError:
                return None
        elif indexClass == "edge":
            try:
                return Index(indexName, indexClass, "manual",
                        self.neograph.relationships.indexes.get(indexName))
            except client.NotFoundError:
                return None
        else:
            raise KeyError("Unknown Index Class (%s). Use vertex or edge"\
                    % indexClass)
442090
def _get_single_depth(self, multi_index):
        '''
        
        '''
        single_depth = 0
        for subind in multi_index:
            if is_slice_or_dim_range(subind):
                break
            single_depth += 1
        return single_depth
42147
def index(self, sub, start=None, end=None):
        
        return self.value_no_colors.index(sub, start, end)