Returns the count of missing values in this column
15325
@Override
    public int countMissing() {
        int count = 0;
        for (int i = 0; i < size(); i++) {
            if (getPackedDateTime(i) == DateTimeColumnType.missingValueIndicator()) {
                count++;
            }
        }
        return count;
    }
1257199
def get_count(self, query):
        
        count_q = query.statement.with_only_columns(
            [func.count()]).order_by(None)
        count = query.session.execute(count_q).scalar()
        return count
1158490
public boolean isEmpty() {
        for (int i = 0; i < columns; i++) {
            if (cells[i] != null) {
                return false;
            }
        }
        return true;
    }
22076
def _find_missing(self, data, return_bool=False):
        

        # This returns the full table with True where the condition is true
        if return_bool == False:
            data = self._find_missing_return_frame(data)
            return data

        # This returns a bool selector if any of the column is True
        elif return_bool == "any":
            bool_sel = self._find_missing_return_frame(data).any(axis=0)
            return bool_sel

        # This returns a bool selector if all of the column are True
        elif return_bool == "all":
            bool_sel = self._find_missing_return_frame(data).all(axis=0)
            return bool_sel
        
        else:
            print("error in multi_col_how input")
856862
def is_missing(data, missing_value):
    
    if is_float(data) and isnan(missing_value):
        return isnan(data)
    elif is_datetime(data) and isnat(missing_value):
        return isnat(data)
    return (data == missing_value)
781382
def value_counts(self, dropna=False):
        
        from pandas import Series, Index

        if dropna:
            values = self[~self.isna()]._data
        else:
            values = self._data

        cls = type(self)

        result = value_counts(values, sort=False, dropna=dropna)
        index = Index(cls(result.index.view('i8'), dtype=self.dtype),
                      name=result.index.name)
        return Series(result.values, index=index, name=result.name)
955284
public function colCount() {
		$count=$this->count();
		if ($this->hasOnlyCols($count))
			return $count;
		if ($count > 0)
			return $this->getItem(0)->count();
		return 0;
	}
1065329
def column_count(index = Celerity.index_offset)
      assert_exists
      @object.getRow(index - Celerity.index_offset).getCells.length
    end
994213
def columnCount(self, parent=None):
        
        if self._separateFieldOrientation == Qt.Horizontal:
            return self._nCols * len(self._fieldNames)
        else:
            return self._nCols
1247990
def countByValue(self):
        
        return self.map(lambda x: (x, 1)).reduceByKey(lambda x, y: x+y)
530114
def find_missing(message, all_params, given_opts, default_opts, header=None, prompt_missing=True):
    

    # are we missing anything?
    missing_params = list(set(all_params) - set(given_opts))

    num_prompted = 0

    if not missing_params:
        return given_opts, missing_params, num_prompted

    if not prompt_missing:
        # count the number missing, and go with defaults
        missing_values = set(default_opts) - set(given_opts)
        num_prompted = len(missing_values)
        given_opts.update(default_opts)

    else:
        if header is not None:
            print('-' * len(header))
            print(header)

        missing_values = interactive_prompt(message, missing_params, default_opts)
        num_prompted = len(missing_values)
        given_opts.update(missing_values)

    return given_opts, missing_params, num_prompted
848788
def count_star(self) -> int:
        
        count_query = (self.statement.with_only_columns([func.count()])
                       .order_by(None))
        return self.session.execute(count_query).scalar()
998768
private function checkCount(){
        $cnt = (int) $this->getMaxEntries();
        if ($cnt !== NULL && count($this->values) !== $cnt){
            trigger_error("Wrong count of Elements. Expected are $cnt. But right now there are ". count($this->values));
        }

    }
88315
def columnCount(self, parent=QtCore.QModelIndex()):
        
        if parent.isValid():
            return self._stim.columnCount(parent.row())
        else:
            return self._stim.columnCount()
204602
def value_count(x, value):
    
    if not isinstance(x, (np.ndarray, pd.Series)):
        x = np.asarray(x)

    if np.isnan(value):
        return np.isnan(x).sum()
    else:
        return x[x == value].size
140390
public static function COUNTBLANK()
    {
        $returnValue = 0;

        // Loop through arguments
        $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
        foreach ($aArgs as $arg) {
            // Is it a blank cell?
            if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) {
                ++$returnValue;
            }
        }

        return $returnValue;
    }
809562
def count_(self):
        
        try:
            num = len(self.df.index)
        except Exception as e:
            self.err(e, "Can not count data")
            return
        return num