我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.floating()。
def do(self, a, b): arr = np.asarray(a) m, n = arr.shape u, s, vt = linalg.svd(a, 0) x, residuals, rank, sv = linalg.lstsq(a, b) if m <= n: assert_almost_equal(b, dot(a, x)) assert_equal(rank, m) else: assert_equal(rank, n) assert_almost_equal(sv, sv.__array_wrap__(s)) if rank == n and m > n: expect_resids = ( np.asarray(abs(np.dot(a, x) - b)) ** 2).sum(axis=0) expect_resids = np.asarray(expect_resids) if len(np.asarray(b).shape) == 1: expect_resids.shape = (1,) assert_equal(residuals.shape, expect_resids.shape) else: expect_resids = np.array([]).view(type(x)) assert_almost_equal(residuals, expect_resids) assert_(np.issubdtype(residuals.dtype, np.floating)) assert_(imply(isinstance(b, matrix), isinstance(x, matrix))) assert_(imply(isinstance(b, matrix), isinstance(residuals, matrix)))
def unique1d(values): """ Hash table-based unique """ if np.issubdtype(values.dtype, np.floating): table = _hash.Float64HashTable(len(values)) uniques = np.array(table.unique(_ensure_float64(values)), dtype=np.float64) elif np.issubdtype(values.dtype, np.datetime64): table = _hash.Int64HashTable(len(values)) uniques = table.unique(_ensure_int64(values)) uniques = uniques.view('M8[ns]') elif np.issubdtype(values.dtype, np.timedelta64): table = _hash.Int64HashTable(len(values)) uniques = table.unique(_ensure_int64(values)) uniques = uniques.view('m8[ns]') elif np.issubdtype(values.dtype, np.integer): table = _hash.Int64HashTable(len(values)) uniques = table.unique(_ensure_int64(values)) else: table = _hash.PyObjectHashTable(len(values)) uniques = table.unique(_ensure_object(values)) return uniques
def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) self.assertTrue(issubclass(df.FloatCol.dtype.type, np.floating), "FloatCol loaded with incorrect type") self.assertTrue(issubclass(df.IntCol.dtype.type, np.integer), "IntCol loaded with incorrect type") self.assertTrue(issubclass(df.BoolCol.dtype.type, np.bool_), "BoolCol loaded with incorrect type") # Int column with NA values stays as float self.assertTrue(issubclass(df.IntColWithNull.dtype.type, np.floating), "IntColWithNull loaded with incorrect type") # Bool column with NA values becomes object self.assertTrue(issubclass(df.BoolColWithNull.dtype.type, np.object), "BoolColWithNull loaded with incorrect type")
def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) self.assertTrue(issubclass(df.FloatCol.dtype.type, np.floating), "FloatCol loaded with incorrect type") self.assertTrue(issubclass(df.IntCol.dtype.type, np.integer), "IntCol loaded with incorrect type") # sqlite has no boolean type, so integer type is returned self.assertTrue(issubclass(df.BoolCol.dtype.type, np.integer), "BoolCol loaded with incorrect type") # Int column with NA values stays as float self.assertTrue(issubclass(df.IntColWithNull.dtype.type, np.floating), "IntColWithNull loaded with incorrect type") # Non-native Bool column with NA values stays as float self.assertTrue(issubclass(df.BoolColWithNull.dtype.type, np.floating), "BoolColWithNull loaded with incorrect type")
def test_default_type_conversion(self): df = sql.read_sql_table("types_test_data", self.conn) self.assertTrue(issubclass(df.FloatCol.dtype.type, np.floating), "FloatCol loaded with incorrect type") self.assertTrue(issubclass(df.IntCol.dtype.type, np.integer), "IntCol loaded with incorrect type") # MySQL has no real BOOL type (it's an alias for TINYINT) self.assertTrue(issubclass(df.BoolCol.dtype.type, np.integer), "BoolCol loaded with incorrect type") # Int column with NA values stays as float self.assertTrue(issubclass(df.IntColWithNull.dtype.type, np.floating), "IntColWithNull loaded with incorrect type") # Bool column with NA = int column with NA values => becomes float self.assertTrue(issubclass(df.BoolColWithNull.dtype.type, np.floating), "BoolColWithNull loaded with incorrect type")
def _handle_date_column(col, format=None): if isinstance(format, dict): return to_datetime(col, errors='ignore', **format) else: if format in ['D', 's', 'ms', 'us', 'ns']: return to_datetime(col, errors='coerce', unit=format, utc=True) elif (issubclass(col.dtype.type, np.floating) or issubclass(col.dtype.type, np.integer)): # parse dates as timestamp format = 's' if format is None else format return to_datetime(col, errors='coerce', unit=format, utc=True) elif com.is_datetime64tz_dtype(col): # coerce to UTC timezone # GH11216 return (to_datetime(col, errors='coerce') .astype('datetime64[ns, UTC]')) else: return to_datetime(col, errors='coerce', format=format, utc=True)
def inner(a, b): """ Returns the inner product of a and b for arrays of floating point types. Like the generic NumPy equivalent the product sum is over the last dimension of a and b. Notes ----- The first argument is not conjugated. """ fa = filled(a, 0) fb = filled(b, 0) if len(fa.shape) == 0: fa.shape = (1,) if len(fb.shape) == 0: fb.shape = (1,) return np.inner(fa, fb).view(MaskedArray)
def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() elif isinstance(obj, WhitespaceNLP.Doc): return repr(obj) elif isinstance(obj, AsianNLP.Doc): return repr(obj) elif 'spacy' in sys.modules: import spacy if isinstance(obj, spacy.tokens.doc.Doc): return repr(obj) else: return super(MyEncoder, self).default(obj)
def array_serializer(data, **kwargs): """Convert the array data to a serialized binary format""" if isinstance(data.flatten()[0], np.floating): use_dtype = '<f4' nan_mask = ~np.isnan(data) assert np.allclose( data.astype(use_dtype)[nan_mask], data[nan_mask]), \ 'Converting the type should not screw things up.' elif isinstance(data.flatten()[0], np.integer): use_dtype = '<i4' assert (data.astype(use_dtype) == data).all(), \ 'Converting the type should not screw things up.' else: raise TypeError('Must be a float or an int: {}'.format(data.dtype)) data_file = NamedTemporaryFile('rb+', suffix='.dat') data.astype(use_dtype).tofile(data_file.file) data_file.seek(0) return FileProp(data_file, use_dtype)
def upcast_float16_ufunc(fn): """Decorator that enforces computation is not done in float16 by NumPy. Some ufuncs in NumPy will compute float values on int8 and uint8 in half-precision (float16), which is not enough, and not compatible with the C code. :param fn: numpy ufunc :returns: function similar to fn.__call__, computing the same value with a minimum floating-point precision of float32 """ def ret(*args, **kwargs): out_dtype = numpy.find_common_type( [a.dtype for a in args], [numpy.float16]) if out_dtype == 'float16': # Force everything to float32 sig = 'f' * fn.nin + '->' + 'f' * fn.nout kwargs.update(sig=sig) return fn(*args, **kwargs) return ret
def upcast_int8_nfunc(fn): """Decorator that upcasts input of dtype int8 to float32. This is so that floating-point computation is not carried using half-precision (float16), as some NumPy functions do. :param fn: function computing a floating-point value from inputs :returns: function similar to fn, but upcasting its uint8 and int8 inputs before carrying out the computation. """ def ret(*args, **kwargs): args = list(args) for i, a in enumerate(args): if getattr(a, 'dtype', None) in ('int8', 'uint8'): args[i] = a.astype('float32') return fn(*args, **kwargs) return ret
def _get_inplace_dtype(obj1, obj2): """ Returns the dtype of obj1, Raise error if 1) obj1 is real and obj2 is complex 2) obj1 is integer and obj2 is floating Parameters ---------- obj1 : numpy.ndarray like array obj2 : numpy.ndarray like array Returns ------- out : np.dtype """ if isrealobj(obj1): if iscomplexobj(obj2): raise TypeError("Cannot cast complex dtype to real dtype") if issubclass(obj1.dtype.type, np.integer): if issubclass(obj2.dtype.type, (np.floating, np.complexfloating)): raise TypeError("Cannot cast floating to integer") return obj1.dtype
def _get_common_dtype_with_scalar(scalar, obj1): """ return the common dtype between a native scalar (int, float, complex) and the dtype of an ndarray like array. Parameters ---------- scalar : { int, float, complex } obj1 : numpy.ndarray like array. """ if issubclass(type(scalar), (int, float, np.integer, np.floating)): return obj1.dtype elif issubclass(type(scalar), (complex, np.complexfloating)): if isrealobj(obj1): return floattocomplex(obj1.dtype) else: return obj1.dtype else: raise TypeError("scalar type is not supported")
def default(self, val): if isinstance(val, (datetime)): return str(val) elif isinstance(val, np.integer): return int(val) elif isinstance(val, np.floating): return float(val) elif isinstance(val, np.bool_): return bool(val) elif isinstance(val, np.ndarray): return val.tolist() elif is_proxy(val) or isinstance(val, Artifact): return repr(val) elif callable(val): try: return utils.fn_info(val) except: pass else: try: return super(Encoder, self).default(val) except Exception as e: print("Could not serialize type: {}".format(type(val))) return str(type(val))
def RATWriteArray(rat, array, field, start=0): """ Pure Python implementation of writing a chunk of the RAT from a numpy array. Type of array is coerced to one of the types (int, double, string) supported. Called from RasterAttributeTable.WriteArray """ if array is None: raise ValueError("Expected array of dim 1") # if not the array type convert it to handle lists etc if not isinstance(array, numpy.ndarray): array = numpy.array(array) if array.ndim != 1: raise ValueError("Expected array of dim 1") if (start + array.size) > rat.GetRowCount(): raise ValueError("Array too big to fit into RAT from start position") if numpy.issubdtype(array.dtype, numpy.integer): # is some type of integer - coerce to standard int # TODO: must check this is fine on all platforms # confusingly numpy.int 64 bit even if native type 32 bit array = array.astype(numpy.int32) elif numpy.issubdtype(array.dtype, numpy.floating): # is some type of floating point - coerce to double array = array.astype(numpy.double) elif numpy.issubdtype(array.dtype, numpy.character): # cast away any kind of Unicode etc array = array.astype(numpy.character) else: raise ValueError("Array not of a supported type (integer, double or string)") return RATValuesIONumPyWrite(rat, field, start, array)
def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.ndarray): return obj.tolist() elif isinstance(obj, np.floating): return float(obj) else: return super(MyEncoder, self).default(obj)
def format(self): if callable(self._format): return self._format(self) if isinstance(self.value, (float, np.floating)): if self._format is None: return self._defaultFormat % self.value else: return self._format % self.value else: return asUnicode(self.value)
def writeHDF5Meta(self, root, name, data, **dsOpts): if isinstance(data, np.ndarray): dsOpts['maxshape'] = (None,) + data.shape[1:] root.create_dataset(name, data=data, **dsOpts) elif isinstance(data, list) or isinstance(data, tuple): gr = root.create_group(name) if isinstance(data, list): gr.attrs['_metaType_'] = 'list' else: gr.attrs['_metaType_'] = 'tuple' #n = int(np.log10(len(data))) + 1 for i in range(len(data)): self.writeHDF5Meta(gr, str(i), data[i], **dsOpts) elif isinstance(data, dict): gr = root.create_group(name) gr.attrs['_metaType_'] = 'dict' for k, v in data.items(): self.writeHDF5Meta(gr, k, v, **dsOpts) elif isinstance(data, int) or isinstance(data, float) or isinstance(data, np.integer) or isinstance(data, np.floating): root.attrs[name] = data else: try: ## strings, bools, None are stored as repr() strings root.attrs[name] = repr(data) except: print("Can not store meta data of type '%s' in HDF5. (key is '%s')" % (str(type(data)), str(name))) raise
def save_images(X, save_path): # [0, 1] -> [0,255] if isinstance(X.flatten()[0], np.floating): X = (255.99*X).astype('uint8') n_samples = X.shape[0] rows = int(np.sqrt(n_samples)) while n_samples % rows != 0: rows -= 1 nh, nw = rows, n_samples/rows if X.ndim == 2: X = np.reshape(X, (X.shape[0], int(np.sqrt(X.shape[1])), int(np.sqrt(X.shape[1])))) if X.ndim == 4: # BCHW -> BHWC X = X.transpose(0,2,3,1) h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw, 3)) elif X.ndim == 3: h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw)) for n, x in enumerate(X): j = n/nw i = n%nw img[j*h:j*h+h, i*w:i*w+w] = x imsave(save_path, img)
def save_images(X, save_path): # [0, 1] -> [0,255] if isinstance(X.flatten()[0], np.floating): X = (255.99*X).astype('uint8') n_samples = X.shape[0] rows = int(np.sqrt(n_samples)) while n_samples % rows != 0: rows -= 1 nh, nw = rows, n_samples//rows if X.ndim == 2: X = np.reshape(X, (X.shape[0], int(np.sqrt(X.shape[1])), int(np.sqrt(X.shape[1])))) if X.ndim == 4: # BCHW -> BHWC X = X.transpose(0,2,3,1) h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw, 3)) elif X.ndim == 3: h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw)) for n, x in enumerate(X): j = n//nw i = n%nw img[j*h:j*h+h, i*w:i*w+w] = x imsave(save_path, img)
def _getconv(dtype): """ Find the correct dtype converter. Adapted from matplotlib """ def floatconv(x): x.lower() if b'0x' in x: return float.fromhex(asstr(x)) return float(x) typ = dtype.type if issubclass(typ, np.bool_): return lambda x: bool(int(x)) if issubclass(typ, np.uint64): return np.uint64 if issubclass(typ, np.int64): return np.int64 if issubclass(typ, np.integer): return lambda x: int(float(x)) elif issubclass(typ, np.longdouble): return np.longdouble elif issubclass(typ, np.floating): return floatconv elif issubclass(typ, np.complex): return lambda x: complex(asstr(x)) elif issubclass(typ, np.bytes_): return bytes else: return str
def masked_equal(x, value, copy=True): """ Mask an array where equal to a given value. This function is a shortcut to ``masked_where``, with `condition` = (x == value). For floating point arrays, consider using ``masked_values(x, value)``. See Also -------- masked_where : Mask where a condition is met. masked_values : Mask using floating point equality. Examples -------- >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_equal(a, 2) masked_array(data = [0 1 -- 3], mask = [False False True False], fill_value=999999) """ output = masked_where(equal(x, value), x, copy=copy) output.fill_value = value return output
def sort(a, axis=-1, kind='quicksort', order=None, endwith=True, fill_value=None): "Function version of the eponymous method." a = narray(a, copy=True, subok=True) if axis is None: a = a.flatten() axis = 0 if fill_value is None: if endwith: # nan > inf if np.issubdtype(a.dtype, np.floating): filler = np.nan else: filler = minimum_fill_value(a) else: filler = maximum_fill_value(a) else: filler = fill_value sindx = filled(a, filler).argsort(axis=axis, kind=kind, order=order) # save meshgrid memory for 1d arrays if a.ndim == 1: indx = sindx else: indx = np.meshgrid(*[np.arange(x) for x in a.shape], sparse=True, indexing='ij') indx[axis] = sindx return a[indx]
def test_vector_return_type(self): a = np.array([1, 0, 1]) exact_types = np.typecodes['AllInteger'] inexact_types = np.typecodes['AllFloat'] all_types = exact_types + inexact_types for each_inexact_types in all_types: at = a.astype(each_inexact_types) an = norm(at, -np.inf) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 0.0) with warnings.catch_warnings(): warnings.simplefilter("ignore", RuntimeWarning) an = norm(at, -1) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 0.0) an = norm(at, 0) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 2) an = norm(at, 1) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 2.0) an = norm(at, 2) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 2.0**(1.0/2.0)) an = norm(at, 4) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 2.0**(1.0/4.0)) an = norm(at, np.inf) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 1.0)
def float_samples_to_int16(y): """Convert floating-point numpy array of audio samples to int16.""" if not issubclass(y.dtype.type, np.floating): raise ValueError('input samples not floating-point') return (y * np.iinfo(np.int16).max).astype(np.int16)
def samples_to_wav_data(samples, sample_rate): """Converts floating point samples to wav data.""" wav_io = six.BytesIO() scipy.io.wavfile.write(wav_io, sample_rate, float_samples_to_int16(samples)) return wav_io.getvalue()
def __contains__(self, value, memo=None): if self.dtype is None: raise TypeError("cannot determine if {0} is in {1}: no dtype specified".format(repr(value), self)) if self.dims is None: raise TypeError("cannot determine if {0} is in {1}: no dims specified".format(repr(value), self)) if value is None: return self.nullable def recurse(value, dims): if dims == (): if issubclass(self.dtype.type, (numpy.bool_, numpy.bool)): return value is True or value is False elif issubclass(self.dtype.type, numpy.integer): iinfo = numpy.iinfo(self.dtype.type) return isinstance(value, numbers.Integral) and iinfo.min <= value <= iinfo.max elif issubclass(self.dtype.type, numpy.floating): return isinstance(value, numbers.Real) elif issubclass(self.dtype.type, numpy.complex): return isinstance(value, numbers.Complex) else: raise TypeError("unexpected dtype: {0}".format(self.dtype)) else: try: iter(value) len(value) except TypeError: return False else: return len(value) == dims[0] and all(recurse(x, dims[1:]) for x in value) return recurse(value, self.dims)
def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(JSONEncoder, self).default(obj)
def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() elif isinstance(obj, np.bool_): return bool(obj) elif isinstance(obj, set): return list(obj) else: return super(MyEncoder, self).default(obj)
def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(MsgEncoder, self).default(obj) #Normalized versions with summary stats to be sent to the cloud
def sanitize_dataframe(df): """Sanitize a DataFrame to prepare it for serialization. * Make a copy * Raise ValueError if it has a hierarchical index. * Convert categoricals to strings. * Convert np.int dtypes to Python int objects * Convert floats to objects and replace NaNs by None. * Convert DateTime dtypes into appropriate string representations """ import pandas as pd import numpy as np df = df.copy() if isinstance(df.index, pd.core.index.MultiIndex): raise ValueError('Hierarchical indices not supported') if isinstance(df.columns, pd.core.index.MultiIndex): raise ValueError('Hierarchical indices not supported') for col_name, dtype in df.dtypes.iteritems(): if str(dtype) == 'category': # XXXX: work around bug in to_json for categorical types # https://github.com/pydata/pandas/issues/10778 df[col_name] = df[col_name].astype(str) elif np.issubdtype(dtype, np.integer): # convert integers to objects; np.int is not JSON serializable df[col_name] = df[col_name].astype(object) elif np.issubdtype(dtype, np.floating): # For floats, convert nan->None: np.float is not JSON serializable col = df[col_name].astype(object) df[col_name] = col.where(col.notnull(), None) elif str(dtype).startswith('datetime'): # Convert datetimes to strings # astype(str) will choose the appropriate resolution df[col_name] = df[col_name].astype(str).replace('NaT', '') return df
def default(self, obj): if isinstance(obj, numpy.integer): return int(obj) elif isinstance(obj, numpy.floating): return float(obj) elif isinstance(obj, numpy.ndarray): return obj.tolist() else: return super(MyEncoder, self).default(obj)
def filternsaval(context, value, key): ''' Parse plateifu or mangaid into better form ''' if type(value) == list: newvalue = ', '.join([str(np.round(v, 4)) for v in value]) elif isinstance(value, (float, np.floating)): newvalue = np.round(value, 4) else: newvalue = value return newvalue
def save_images(X, save_path): # [0, 1] -> [0,255] if isinstance(X.flatten()[0], np.floating): X = (255.99*X).astype('uint8') n_samples = X.shape[0] rows = int(np.sqrt(n_samples)) while n_samples % rows != 0: rows -= 1 nh, nw = rows, n_samples//rows if X.ndim == 2: X = np.reshape(X, (X.shape[0], int(np.sqrt(X.shape[1])), int(np.sqrt(X.shape[1])))) if X.ndim == 4: # BCHW -> BHWC X = X.transpose(0,2,3,1) h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw, 3)) elif X.ndim == 3: h, w = X[0].shape[:2] img = np.zeros((h*nh, w*nw)) for n, x in enumerate(X): #j = n/nw #i = n%nw j, i = divmod(n, nw) img[j*h:j*h+h, i*w:i*w+w] = x imsave(save_path, img)
def is_floating(self): return self.inferred_type in ['floating', 'mixed-integer-float']
def is_numeric(self): return self.inferred_type in ['integer', 'floating']
def _maybe_cast_indexer(self, key): """ If we have a float key and are not a floating index then try to cast to an int if equivalent """ if is_float(key) and not self.is_floating(): try: ckey = int(key) if ckey == key: key = ckey except (ValueError, TypeError): pass return key
def _can_hold_element(self, element): if is_list_like(element): element = np.array(element) tipo = element.dtype.type return (issubclass(tipo, (np.floating, np.integer)) and not issubclass(tipo, (np.datetime64, np.timedelta64))) return (isinstance(element, (float, int, np.float_, np.int_)) and not isinstance(element, (bool, np.bool_, datetime, timedelta, np.datetime64, np.timedelta64)))
