我们从Python开源项目中，提取了以下19个代码示例，用于说明如何使用numpy.inexact()。
def _replace_nan(a, val): """ If `a` is of inexact type, make a copy of `a`, replace NaNs with the `val` value, and return the copy together with a boolean mask marking the locations where NaNs were present. If `a` is not of inexact type, do nothing and return `a` together with a mask of None. Note that scalars will end up as array scalars, which is important for using the result as the value of the out argument in some operations. Parameters ---------- a : array-like Input array. val : float NaN values are set to val before doing the operation. Returns ------- y : ndarray If `a` is of inexact type, return a copy of `a` with the NaNs replaced by the fill value, otherwise return `a`. mask: {bool, None} If `a` is of inexact type, return a boolean mask marking locations of NaNs, otherwise return None. """ is_new = not isinstance(a, np.ndarray) if is_new: a = np.array(a) if not issubclass(a.dtype.type, np.inexact): return a, None if not is_new: # need copy a = np.array(a, subok=True) mask = np.isnan(a) np.copyto(a, val, where=mask) return a, mask
def _divide_by_count(a, b, out=None): """ Compute a/b ignoring invalid results. If `a` is an array the division is done in place. If `a` is a scalar, then its type is preserved in the output. If out is None, then then a is used instead so that the division is in place. Note that this is only called with `a` an inexact type. Parameters ---------- a : {ndarray, numpy scalar} Numerator. Expected to be of inexact type but not checked. b : {ndarray, numpy scalar} Denominator. out : ndarray, optional Alternate output array in which to place the result. The default is ``None``; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. Returns ------- ret : {ndarray, numpy scalar} The return value is a/b. If `a` was an ndarray the division is done in place. If `a` is a numpy scalar, the division preserves its type. """ with np.errstate(invalid='ignore'): if isinstance(a, np.ndarray): if out is None: return np.divide(a, b, out=a, casting='unsafe') else: return np.divide(a, b, out=out, casting='unsafe') else: if out is None: return a.dtype.type(a / b) else: # This is questionable, but currently a numpy scalar can # be output to a zero dimensional array. return np.divide(a, b, out=out, casting='unsafe')
def minimum_dtype(x, dtype=np.bool_): """returns the "most basic" dtype which represents `x` properly, which provides at least the same value range as the specified dtype.""" def check_type(x, dtype): try: converted = dtype.type(x) except (ValueError, OverflowError): return False # False if some overflow has happened return converted == x or math.isnan(x) def type_loop(x, dtype, dtype_dict, default=None): while True: try: dtype = np.dtype(dtype_dict[dtype.name]) if check_type(x, dtype): return np.dtype(dtype) except KeyError: if default is not None: return np.dtype(default) raise ValueError("Can not determine dtype of %r" % x) dtype = np.dtype(dtype) if check_type(x, dtype): return dtype if np.issubdtype(dtype, np.inexact): return type_loop(x, dtype, _next_float_dtype) else: return type_loop(x, dtype, _next_int_dtype, default=np.float32)
def _divide_by_count(a, b, out=None): """ Compute a/b ignoring invalid results. If `a` is an array the division is done in place. If `a` is a scalar, then its type is preserved in the output. If out is None, then then a is used instead so that the division is in place. Note that this is only called with `a` an inexact type. Parameters ---------- a : {ndarray, numpy scalar} Numerator. Expected to be of inexact type but not checked. b : {ndarray, numpy scalar} Denominator. out : ndarray, optional Alternate output array in which to place the result. The default is ``None``; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. Returns ------- ret : {ndarray, numpy scalar} The return value is a/b. If `a` was an ndarray the division is done in place. If `a` is a numpy scalar, the division preserves its type. """ with np.errstate(invalid='ignore', divide='ignore'): if isinstance(a, np.ndarray): if out is None: return np.divide(a, b, out=a, casting='unsafe') else: return np.divide(a, b, out=out, casting='unsafe') else: if out is None: return a.dtype.type(a / b) else: # This is questionable, but currently a numpy scalar can # be output to a zero dimensional array. return np.divide(a, b, out=out, casting='unsafe')
def _median(a, axis=None, out=None, overwrite_input=False): # can't be reasonably be implemented in terms of percentile as we have to # call mean to not break astropy a = np.asanyarray(a) # Set the partition indexes if axis is None: sz = a.size else: sz = a.shape[axis] if sz % 2 == 0: szh = sz // 2 kth = [szh - 1, szh] else: kth = [(sz - 1) // 2] # Check if the array contains any nan's if np.issubdtype(a.dtype, np.inexact): kth.append(-1) if overwrite_input: if axis is None: part = a.ravel() part.partition(kth) else: a.partition(kth, axis=axis) part = a else: part = partition(a, kth, axis=axis) if part.shape == (): # make 0-D arrays work return part.item() if axis is None: axis = 0 indexer = [slice(None)] * part.ndim index = part.shape[axis] // 2 if part.shape[axis] % 2 == 1: # index with slice to allow mean (below) to work indexer[axis] = slice(index, index+1) else: indexer[axis] = slice(index-1, index+1) # Check if the array contains any nan's if np.issubdtype(a.dtype, np.inexact) and sz > 0: # warn and return nans like mean would rout = mean(part[indexer], axis=axis, out=out) return np.lib.utils._median_nancheck(part, rout, axis, out) else: # if there are no nans # Use mean in odd and even case to coerce data type # and check, use out array. return mean(part[indexer], axis=axis, out=out)
def object_to_json(o, level=0, indent=4, space=" ", newline="\n"): ret = "" if isinstance(o, dict): ret += "{" + newline comma = "" for k,v in o.iteritems(): ret += comma comma = ",\n" ret += space * indent * level ret += '"' + str(k) + '":' + space ret += object_to_json(v, level + 1) ret += newline + space * indent * (level - 1) + "}" elif isinstance(o, basestring): ret += '"' + o + '"' elif isinstance(o, list): ret += "[" + ", ".join([object_to_json(e, level+1) for e in o]) + "]" elif isinstance(o, bool): ret += "true" if o else "false" elif isinstance(o, (int, long)): ret += str(o) elif isinstance(o, datetime): ret += o.strftime('%Y-%m-%d %H:%M:%S.%f') elif isinstance(o, bson.ObjectId): ret += 'ObjectId(%s)' % o elif isinstance(o, float): ret += '%.7g' % o elif isinstance(o, numpy.ndarray) and numpy.issubdtype(o.dtype, numpy.integer): ret += "[" + ','.join(map(str, o.flatten().tolist())) + "]" elif isinstance(o, numpy.ndarray) and numpy.issubdtype(o.dtype, numpy.inexact): ret += "[" + ','.join(map(lambda x: '%.7g' % x, o.flatten().tolist())) + "]" elif isinstance(o, bson.timestamp.Timestamp): ret += o.as_datetime().strftime('%Y-%m-%d %H:%M:%S.%f') elif o is None: ret += 'null' else: raise TypeError("Unknown type '%s' for json serialization" % str(type(o))) return ret
def nan_to_num(array, fill_value = 0.0, copy = True): """ Replace NaNs with another fill value. Parameters ---------- array : array_like Input data. fill_value : float, optional NaNs will be replaced by ``fill_value``. Default is 0.0, in keeping with ``numpy.nan_to_num``. copy : bool, optional Whether to create a copy of `array` (True) or to replace values in-place (False). The in-place operation only occurs if casting to an array does not require a copy. Returns ------- out : ndarray Array without NaNs. If ``array`` was not of floating or complearray type, ``array`` is returned unchanged. Notes ----- Contrary to ``numpy.nan_to_num``, this functions does not handle infinite values. See Also -------- numpy.nan_to_num : replace NaNs and Infs with zeroes. """ array = np.array(array, subok = True, copy = copy) dtype = array.dtype.type # Non-inexact types do not have NaNs if not np.issubdtype(dtype, np.inexact): return array iscomplex = np.issubdtype(dtype, np.complexfloating) dest = (array.real, array.imag) if iscomplex else (array,) for d in dest: np.copyto(d, fill_value, where = np.isnan(d)) return array
def to_json(o, level=0): INDENT = 2 SPACE = " " NEWLINE = "\n" ret = "" if isinstance(o, dict): ret += "{" + NEWLINE comma = "" for k in sorted(o.keys()): v = o[k] ret += comma comma = ",\n" ret += SPACE * INDENT * (level+1) ret += '"' + str(k) + '":' + SPACE ret += to_json(v, level + 1) ret += NEWLINE + SPACE * INDENT * level + "}" elif isinstance(o, str): ret += '"' + o + '"' elif isinstance(o, list) or isinstance(o, tuple): ret += "[" + ",".join([to_json(e, level+1) for e in o]) + "]" elif isinstance(o, bool): ret += "true" if o else "false" elif isinstance(o, int): ret += str(o) elif isinstance(o, float): ret += '%.7g' % o elif isinstance(o, np.ndarray) and np.issubdtype(o.dtype, np.integer): ret += "[" + ','.join(map(str, o.flatten().tolist())) + "]" elif isinstance(o, np.ndarray) and np.issubdtype(o.dtype, np.inexact): ret += "[" + \ ','.join(map(lambda x: '%.7g' % x, o.flatten().tolist())) + "]" elif o is None: ret += 'null' elif hasattr(o, '__class__'): ret += '"' + o.__class__.__name__ + '"' else: raise TypeError( "Unknown type '%s' for json serialization" % str(type(o))) return ret # format object and its properties into printable dict
def check_dtype(dtype, func_str, a, n): if np.isscalar(a) or not a.shape: if func_str not in ("sum", "prod", "len"): raise ValueError("scalar inputs are supported only for 'sum', " "'prod' and 'len'") a_dtype = np.dtype(type(a)) else: a_dtype = a.dtype if dtype is not None: # dtype set by the user # Careful here: np.bool != np.bool_ ! if np.issubdtype(dtype, np.bool_) and \ not('all' in func_str or 'any' in func_str): raise TypeError("function %s requires a more complex datatype " "than bool" % func_str) if not np.issubdtype(dtype, np.integer) and func_str in ('len', 'nanlen'): raise TypeError("function %s requires an integer datatype" % func_str) # TODO: Maybe have some more checks here return np.dtype(dtype) else: try: return np.dtype(_forced_types[func_str]) except KeyError: if func_str in _forced_float_types: if np.issubdtype(a_dtype, np.floating): return a_dtype else: return np.dtype(np.float64) else: if func_str == 'sum': # Try to guess the minimally required int size if np.issubdtype(a_dtype, np.int64): # It's not getting bigger anymore # TODO: strictly speaking it might need float return np.dtype(np.int64) elif np.issubdtype(a_dtype, np.integer): maxval = np.iinfo(a_dtype).max * n return minimum_dtype(maxval, a_dtype) elif np.issubdtype(a_dtype, np.bool_): return minimum_dtype(n, a_dtype) else: # floating, inexact, whatever return a_dtype elif func_str in _forced_same_type: return a_dtype else: if isinstance(a_dtype, np.integer): return np.dtype(np.int64) else: return a_dtype
def _median(a, axis=None, out=None, overwrite_input=False): if overwrite_input: if axis is None: asorted = a.ravel() asorted.sort() else: a.sort(axis=axis) asorted = a else: asorted = sort(a, axis=axis) if axis is None: axis = 0 elif axis < 0: axis += asorted.ndim if asorted.ndim == 1: idx, odd = divmod(count(asorted), 2) return asorted[idx + odd - 1 : idx + 1].mean(out=out) counts = count(asorted, axis=axis) h = counts // 2 # create indexing mesh grid for all but reduced axis axes_grid = [np.arange(x) for i, x in enumerate(asorted.shape) if i != axis] ind = np.meshgrid(*axes_grid, sparse=True, indexing='ij') # insert indices of low and high median ind.insert(axis, np.maximum(0, h - 1)) low = asorted[tuple(ind)] ind[axis] = h high = asorted[tuple(ind)] # duplicate high if odd number of elements so mean does nothing odd = counts % 2 == 1 if asorted.ndim > 1: np.copyto(low, high, where=odd) elif odd: low = high if np.issubdtype(asorted.dtype, np.inexact): # avoid inf / x = masked s = np.ma.sum([low, high], axis=0, out=out) np.true_divide(s.data, 2., casting='unsafe', out=s.data) else: s = np.ma.mean([low, high], axis=0, out=out) return s
