Return if each value is NaN.
192082
def _isnan(self):
        
        if self._can_hold_na:
            return isna(self)
        else:
            # shouldn't reach to this condition by checking hasnans beforehand
            values = np.empty(len(self), dtype=np.bool_)
            values.fill(False)
            return values
641504
def is_number(num, if_bool=False):
    

    if isinstance(num, bool):
        return if_bool
    elif isinstance(num, int):
        return True
    try:
        number = float(num)
        return not (isnan(number) or isinf(number))
    except (TypeError, ValueError):
        return False
646043
def is_numeric_dtype(dtype):
    """"""
    dtype = np.dtype(dtype)
    return np.issubsctype(getattr(dtype, 'base', None), np.number)
1327749
def value_is_int(self):
        """"""
        try:
            a = float(self.value)
            b = int(a)
        except ValueError:
            return False
        else:
            return a == b
590195
def is_scalar(value: Any) -> bool:
    
    return (
        getattr(value, 'ndim', None) == 0 or
        isinstance(value, (str, bytes)) or not
        isinstance(value, (Iterable, ) + dask_array_type))
548429
def na_if(series, *values):
    

    series = pd.Series(series)
    series[series.isin(values)] = np.nan
    return series
86983
def _check_constant_value_data(self, data):
        """"""

        arrayval = data.flat[0]
        if np.all(data == arrayval):
            return arrayval
        return None
1364391
def contains_all(self, other):
        """"""
        dtype = getattr(other, 'dtype', None)
        if dtype is None:
            dtype = np.result_type(*other)
        return is_numeric_dtype(dtype)
89713
function(value) {
    var d = FxoUtils.parseDateTimeField(value);
    return d.valid ? d.parsed.getTime() : NaN;
  }
113999
public boolean containsFloat(float value) {
		boolean isNan = Float.isNaN(value);
		for (int i = 1; i < maxPoolSize; i++) {
			if (types[i] == FLOAT) {
				float f = readFloat(i);
				if (f == value || (isNan && Float.isNaN(f))) return true;
			}
		}
		return false;
	}
1038960
def is_null(value, msg=None, except_=None):
    '''
    
    '''
    # dataframes, even if empty, are not considered null
    value = False if hasattr(value, 'empty') else value
    result = bool(
        value is None or
        value != value or
        repr(value) == 'NaT')
    if except_:
        return is_true(result, msg=msg, except_=except_)
    else:
        return bool(result)
106274
def _check_color_dim(val):
    """"""
    val = np.atleast_2d(val)
    if val.shape[1] not in (3, 4):
        raise RuntimeError('Value must have second dimension of size 3 or 4')
    return val, val.shape[1]
474843
def _check_values(self, values):
        """"""
        assert isinstance(values, Iterable) and not isinstance(
            values, (str, dict, bytes, bytearray)), \
            'values should be a list or tuple. Got {}'.format(type(values))
        if self.header.analysis_period.is_annual:
            a_period_len = 8760 * self.header.analysis_period.timestep
            if self.header.analysis_period.is_leap_year is True:
                a_period_len = a_period_len + 24 * self.header.analysis_period.timestep
        else:
            a_period_len = len(self.header.analysis_period.moys)
        assert len(values) == a_period_len, \
            'Length of values does not match that expected by the '\
            'header analysis_period. {} != {}'.format(len(values), a_period_len)
375351
def drop_nan_columns(df, thresh=325):
    
    if thresh < 1:
        thresh = int(thresh * df)
    return df.dropna(axis=1, thresh=thresh, inplace=False)
603111
public void invalidateAll() {
		int N = width*height;
		for( int i = 0; i < N; i++ )
			data[i].x = Float.NaN;
	}
590091
def number(v):
    """"""
    if nodesetp(v):
        v = string(v)
    try:
        return float(v)
    except ValueError:
        return float('NaN')
1024103
def isnumber(*args):
    
    return all(map(lambda c: isinstance(c, int) or isinstance(c, float), args))