我们从Python开源项目中，提取了以下32个代码示例，用于说明如何使用numpy.float128()。
def numpy2bifrost(dtype): if dtype == np.int8: return _bf.BF_DTYPE_I8 elif dtype == np.int16: return _bf.BF_DTYPE_I16 elif dtype == np.int32: return _bf.BF_DTYPE_I32 elif dtype == np.uint8: return _bf.BF_DTYPE_U8 elif dtype == np.uint16: return _bf.BF_DTYPE_U16 elif dtype == np.uint32: return _bf.BF_DTYPE_U32 elif dtype == np.float16: return _bf.BF_DTYPE_F16 elif dtype == np.float32: return _bf.BF_DTYPE_F32 elif dtype == np.float64: return _bf.BF_DTYPE_F64 elif dtype == np.float128: return _bf.BF_DTYPE_F128 elif dtype == ci8: return _bf.BF_DTYPE_CI8 elif dtype == ci16: return _bf.BF_DTYPE_CI16 elif dtype == ci32: return _bf.BF_DTYPE_CI32 elif dtype == cf16: return _bf.BF_DTYPE_CF16 elif dtype == np.complex64: return _bf.BF_DTYPE_CF32 elif dtype == np.complex128: return _bf.BF_DTYPE_CF64 elif dtype == np.complex256: return _bf.BF_DTYPE_CF128 else: raise ValueError("Unsupported dtype: " + str(dtype))
def numpy2string(dtype): if dtype == np.int8: return 'i8' elif dtype == np.int16: return 'i16' elif dtype == np.int32: return 'i32' elif dtype == np.int64: return 'i64' elif dtype == np.uint8: return 'u8' elif dtype == np.uint16: return 'u16' elif dtype == np.uint32: return 'u32' elif dtype == np.uint64: return 'u64' elif dtype == np.float16: return 'f16' elif dtype == np.float32: return 'f32' elif dtype == np.float64: return 'f64' elif dtype == np.float128: return 'f128' elif dtype == np.complex64: return 'cf32' elif dtype == np.complex128: return 'cf64' elif dtype == np.complex256: return 'cf128' else: raise TypeError("Unsupported dtype: " + str(dtype))
def watts_threshold(self, m): """ The watts threshold function. Input --------------- m [number] : Number of active neigbors Return --------------- [float] : Probability of activation """ if m >= self.params["params"]["threshold"]: return np.float128(self.params["params"]["p"]) else: return np.float128(0.0) return
def bond_percolation(self, m): """ The bond percolation response function Input --------------- m [number] : Number of active neigbors Return --------------- [float] : Probability of activation """ if m > 0: return (np.float128(1.0) - np.float128((1.0 - self.params["params"]["p"]) ** m)*(1.0-np.float128(self.params["params"]["p_spontaneous"]))) else: return np.float128(self.params["params"]["p_spontaneous"])
def json_encode(obj): try: serial = obj.to_json() serial['classname'] = obj.__class__.__qualname__ return serial except AttributeError: pass # Convert numpy types: if type(obj) in [np.int8, np.int16, np.int32, np.int64]: return int(obj) elif type(obj) in [np.float16, np.float32, np.float64, np.float128]: return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() if isinstance(obj, datetime.datetime): return obj.isoformat() raise TypeError('Type not serialisable')
def test_returned_dtype(self): dtypes = [np.int16, np.int32, np.int64, np.float32, np.float64] if hasattr(np, 'float128'): dtypes.append(np.float128) for dtype in dtypes: s = Series(range(10), dtype=dtype) group_a = ['mean', 'std', 'var', 'skew', 'kurt'] group_b = ['min', 'max'] for method in group_a + group_b: result = getattr(s, method)() if is_integer_dtype(dtype) and method in group_a: self.assertTrue( result.dtype == np.float64, "return dtype expected from %s is np.float64, " "got %s instead" % (method, result.dtype)) else: self.assertTrue( result.dtype == dtype, "return dtype expected from %s is %s, " "got %s instead" % (method, dtype, result.dtype))
def hashint64(x,N): ''' Convert a bit vector to a float128 Not to be confused with `pylab.packbits` Parameters ---------- x : boolean or binary vector N : positive integer, number of bits in each vector Returns ------- int64 : integer, stored in int64, whose binary bits match x ''' if N>63: raise ValueError('No more than 63 bits can be safely stored in int64') return x.dot(2**np.int64(np.arange(N)))
def hashfloat128(x,N): ''' Convert a bit vector to a float128 Not to be confused with `pylab.packbits` Parameters ---------- x : boolean or binary vector N : positive integer, number of bits in each vector Returns ------- float128 : integer, stored in float128, whose binary bits match x ''' x = (np.array(x)!=0) if not x.shape[-1]==N: raise ValueError('The last dimension of x should match the bit vector length N') if N>63: raise ValueError('No more than 63 bits are safe at the moment') return x.dot(2**np.float128(np.arange(N)))
def unhashfloat128(x,N): ''' Unpack bits from number b; inverse of `hashbits()` Not to be confused with `pylab.unpackbits` Parameters ---------- x : float128 integer stored in float128, whose binary bits match x N : positive integer, number of bits in each vector Returns ------- b : boolean or binary vector, unpacked ''' if not x.dtype==np.float128: raise ValueError('Expected to unpack bit data from np.float128') x = x.copy() b = [] for i in range(N): b.append(x%2) x = np.floor(x*0.5) b = (np.uint8(b)==1) return b.T
def _is_class_a_primitive(cls): ''' Check if class is a number or string including numpy numbers :param cls: any class :return: True if class is a primitive class, else False ''' primitives = [ np.float16, np.float32, np.float64, np.float128, np.int8, np.int16, np.int32, np.int64, bool, str, np.uint8, np.uint16, np.uint32, np.uint64, int, float ] return cls in primitives
def softmax_cost(out,y, theta3, filt1, filt2): eout = np.exp(out, dtype=np.float128) probs = eout/sum(eout) p = sum(y*probs) cost = -np.log(p) ## (Only data loss. No regularised loss) return cost,probs ## Returns gradient for all the paramaters in each iteration
def name_nbit2numpy(name, nbit): if name == 'i': if nbit == 8: return np.int8 elif nbit == 16: return np.int16 elif nbit == 32: return np.int32 elif nbit == 64: return np.int64 else: raise TypeError("Invalid signed integer type size: %i" % nbit) elif name == 'u': if nbit == 8: return np.uint8 elif nbit == 16: return np.uint16 elif nbit == 32: return np.uint32 elif nbit == 64: return np.uint64 else: raise TypeError("Invalid unsigned integer type size: %i" % nbit) elif name == 'f': if nbit == 16: return np.float16 elif nbit == 32: return np.float32 elif nbit == 64: return np.float64 elif nbit == 128: return np.float128 else: raise TypeError("Invalid floating-point type size: %i" % nbit) elif name == 'ci': if nbit == 8: return ci8 elif nbit == 16: return ci16 elif nbit == 32: return ci32 # elif name in set(['ci', 'cu']): # Note: This gives integer types in place of proper complex types # return name_nbit2numpy(name[1:], nbit*2) elif name == 'cf': if nbit == 16: return cf16 elif nbit == 32: return np.complex64 elif nbit == 64: return np.complex128 elif nbit == 128: return np.complex256 else: raise TypeError("Invalid complex floating-point type size: %i" % nbit) else: raise TypeError("Invalid type name: " + name)
def test_16byte(self): self.run_simple_test_shmoo(np.float128)
def _print_Float(self, expr): super_float = super()._print_Float(expr) if self._settings['float128']: super_float = 'float128(%r)' % super_float if self._settings['use_autoeye']: return 'autoeye(%s)' % super_float return super_float
def print_features_info(dataset): features_and_types = dataset.dtypes print("\n[Debug] Print the feature number: ") numberic_feature_number = 0 not_numberic_feature_number = 0 for feature_type in features_and_types: if feature_type == np.int16 or feature_type == np.int32 or feature_type == np.int64 or feature_type == np.float16 or feature_type == np.float32 or feature_type == np.float64 or feature_type == np.float128 or feature_type == np.double: numberic_feature_number += 1 else: not_numberic_feature_number += 1 print("Total feature number: {}".format(len(features_and_types))) print("Numberic feature number: {}".format(numberic_feature_number)) print("Not numberic feature number: {}".format(not_numberic_feature_number)) print("\n[Debug] Print the feature list of the dataset: ") print(features_and_types) print("\n[Debug] Print the feature presence: ") example_number = len(dataset) features_array = list(dataset.columns.values) for feature_name in features_array: feature_presence_number = len(dataset[feature_name][dataset[feature_name].notnull()]) feature_presence_percentage = 100.0 * feature_presence_number / example_number # Example: "Age: 80.1346801347% (714 / 891)" print("{}: {}% ({} / {})".format(feature_name, feature_presence_percentage, feature_presence_number, example_number)) print("\n[Debug] For numberic features, print the feature statistics: ") feature_statistics = dataset.describe() print(feature_statistics) top_k_number = 5 print("\n[Debug] For all features, print the top {} values: ".format(top_k_number)) for i in range(len(features_array)): feature_name = features_array[i] top_k_feature_info = dataset[feature_name].value_counts()[:top_k_number] print("\nFeature {} and the top {} values:".format(feature_name, top_k_number)) print(top_k_feature_info)
def test_scalar(): res = x2num.makenp(1.1) assert isinstance(res, np.ndarray) and res.shape == (1,) res = x2num.makenp(1000000000000000000000) assert isinstance(res, np.ndarray) and res.shape == (1,) res = x2num.makenp(np.float16(1.00000087)) assert isinstance(res, np.ndarray) and res.shape == (1,) res = x2num.makenp(np.float128(1.00008+9)) assert isinstance(res, np.ndarray) and res.shape == (1,) res = x2num.makenp(np.int64(100000000000)) assert isinstance(res, np.ndarray) and res.shape == (1,)
def _float(value): t = type(value) floats = [np.float, np.float32, np.float64, np.float128, np.float16, float] return bool(np.sum([t is f for f in floats]))
def test_numpy_float128(self): x = numpy.float128(55.3) s = Serializable.dumps(x) y = Serializable.from_json(s) self.assertAlmostEqual(x, y, 5) self.assertEqual(str(x.dtype), 'float128') self.assertEqual(str(y.dtype), 'float128')
def get_full_conditional(self, sentence, m, z, n_z, n_m_z): prod_nom, prod_den = [] , [] words = Counter(sentence) for key, val in words.iteritems(): for x in range(val): quantity = self.n_z_t[:,key] + self.beta + x prod_nom.append(quantity) # prod_nom *= (quantity) prod_nom = np.array(prod_nom, dtype=np.float128) left_denominator = n_z + self.beta*self.V for x in range(len(sentence)): quantity = left_denominator + x prod_den.append(quantity) # prod_den *= (quantity) prod_den = np.array(prod_den, dtype=np.float128) # print "Shapes of interest:", prod_den.shape, prod_nom.shape prodall1 = np.divide(prod_nom,prod_den) # print "After division:", prodall.shape prodall = np.prod(prodall1, axis=0) # print "After multiplication", prodall.shape # prod_nom = np.prod(prod_nom, axis=0, dtype=np.float128) # prod_den = np.prod(prod_den, axis=0, dtype=np.float128) # left = prod_nom/prod_den right = (n_m_z[m,:] + self.alpha) p_z = prodall*right # try: # p_z /= np.sum(p_z) # except: # print p_z # print prodall1 # print prodall p_z /= np.sum(p_z) # except RuntimeWarning: # print 'Exception' # print prodall # print right # print self.n_z_t[:,key] return p_z.astype(np.float64)
def test_response_function(self): """ Verify the response functions """ for node in self.solver.G.nodes(): self.assertIn("rf", self.solver.G.node[node]) self.assertIsInstance(self.solver.G.node[node]["rf"], ResponseFunction ) self.assertIs(type(self.solver.G.node[node]["rf"].resp_func(0.0)), np.float128) self.assertIs(type(self.solver.G.node[node]["rf"].resp_func(20.0)), np.float128)
def get_probabilities_Q_possible(self, possible_configs): """ Get the probability Q(l;n) for each configuration in the possible_configs dictionnary. The implementation is based on the recursive equation of the paper. Input ---------------------- possible_configs: Dictionnary where keys are the config as a string (i.e. "0101011011") and value are sets of the parent configurations. Return ---------------------- Dictionnary of probabilities where the key is the configuration as a string (e.g. "10101110") and the value is Q(l;n) """ #the master dictionnary dict_config = {} prob_tot = 1.0 #order by size to simplify the calculation possible_config_ordered_by_size = self.regroup_config_by_size(possible_configs) N = len(self.G.nodes()) #Initial configuration initial_config = [0]*N if self.symbolic_: dict_config[self.list_to_string(initial_config)] = "<prod>"+";".join(["G("+str(node)+","+str(0)+")" for node in self.G.nodes()])+"</prod>" else: dict_config[self.list_to_string(initial_config)] = np.float128(np.product([(1.0-self.G.nodes[node]["rf"].resp_func(0)) for node in self.G.nodes()])) prob_tot -= dict_config[self.list_to_string(initial_config)] for size in range(1,N+1): if size in possible_config_ordered_by_size: for config_str in possible_config_ordered_by_size[size]: Q_ln = self.solve_specific_configuration(config_str, dict_config, possible_configs) dict_config[config_str] = Q_ln prob_tot -= Q_ln dict_config["1"*N] = prob_tot return dict_config
def jk(D,Bs,i,j,frac,possible,ri): Num=factorial(ri-1) Den=factorial(N_ij(D,Bs,i,j,ri)+ri-1) frac*=np.float128(Num)/np.float128(Den) for k in range(0,ri): frac*=factorial(N_ijk(D,Bs,i,j,k,ri)) if N_ijk(D,Bs,i,j,k,ri)!=0 : possible=1 return frac,possible
def getCsvData(): dtypes = { "int8_value": numpy.int8, "int16_value": numpy.int16, "int32_value": numpy.int32, # "int64_value": numpy.int64, # OverFlowError "uint8_value": numpy.uint8, "uint16_value": numpy.uint16, "uint32_value": numpy.uint32, # "uint64_value": numpy.uint64, # OverFlowError "float16_value": numpy.float16, "float32_value": numpy.float32, "float64_value": numpy.float64, # "float128_value": numpy.float128, "bool_value": numpy.bool_ } delimiter = "," encoding = "utf-8" parse_dates = ["timestamp_value"] path = os.path.join(os.getcwdu(), "examples/testData/test1.csv") if not os.path.exists(path): path = os.path.join(os.getcwdu(), "testData/test1.csv") df = pandas.read_csv( path, dtype=dtypes, delimiter=delimiter, encoding=encoding, parse_dates=parse_dates ) try: df["int64_value"] = df["int64_value"].astype(numpy.int64) df["uint64_value"] = df["uint64_value"].astype(numpy.uint64) except: raise return df
def get_worst_live_point(self): """ selects the lowest likelihood live point """ logL_array = np.array([p.logL for p in self.params]) self.worst = logL_array.argmin() self.logLmin.value = logL_array[self.worst] self.logLmax = np.max(logL_array) return np.float128(self.logLmin.value)
def poisson_logpdf(k,l): ''' Gives the log-pdf for a poisson distribution with rate l evaluated at points k. k should be a vector of integers. Parameters ---------- Returns ------- ''' # k,l = map(np.float128,(k,l)) return k*slog(l)-l-np.array([scipy.special.gammaln(x+1) for x in k]) #return k*slog(l)-l-np.array([log_factorial(x) for x in k])
def gaussian_logpdf(mu,sigma,x): ''' Non-positive standar deviations will be clipped Parameters ---------- Returns ------- ''' mu,sigma,x = map(np.float128,(mu,sigma,x)) x = (x-mu)/sigma return -0.5*x*x - slog(sigma) - logsqrt2pi
def sigmoid(x,returntype=LINALGMAXFLOAT): ''' Soft-threshold function (rescaled hyperbolic tangent) More numerically stable version ''' return returntype(sexp(-np.logaddexp(ZERO128,-np.float128(x)))) # Sigmoid and derivatives
def g(x,returntype=LINALGMAXFLOAT): ''' Evaluates g(x)=log(1+exp(x)) as accurately as possible. ''' return returntype(np.logaddexp(ZERO128,np.float128(x)))
def f(x,returntype=LINALGMAXFLOAT): ''' evaluates f(x)=1/(1+exp(-x)) as accurately as possible ''' return returntype(sexp(-np.logaddexp(ZERO128,-np.float128(x))))
def f1(x,returntype=LINALGMAXFLOAT): ''' Fist derivative of sigmoid ''' x = np.float128(x) return sexp(\ -np.logaddexp(ZERO128,-x)\ -np.logaddexp(ZERO128,x), returntype=returntype)
def f2(x,returntype=LINALGMAXFLOAT): ''' Second derivative of sigmoid (q - p) p q ''' x = np.float128(x) logp = -np.logaddexp(ZERO128,-x) logq = -np.logaddexp(ZERO128, x) p = np.exp(np.minimum(F128EMAX,logp)) q = np.exp(np.minimum(F128EMAX,logq)) return returntype((q-p)*q*p);
def sample_patch_projective(image, inv_xform_3x3, patch_shape): """ return a warped image as a numpy array with dtype float64 of size patch_size. if input image is not already of type float64, it will be converted """ P = skimage.transform.ProjectiveTransform(inv_xform_3x3) # skimage clips values to range [0,1] for floating point images. do scale and unscale here. do_scale = False og_dtype = image.dtype if image.dtype in (np.float32, np.float64, np.float128, np.float16): minval = np.nanmin(image) maxval = np.nanmax(image) # if range is good, no need to rescale if minval < 0.0 or maxval > 1.0: do_scale = True # make a copy of image so as not to corrupt original data image = image.copy() scale_factor = maxval - minval image -= minval if scale_factor != 0: image /= scale_factor # do the warping patch = skimage.transform.warp(image, P, output_shape=patch_shape, mode='constant', cval=np.nan) # revert to original type if necessary if og_dtype != patch.dtype: if og_dtype == np.uint8: patch = skimage.img_as_ubyte(patch) elif og_dtype == np.bool: patch = skimage.img_as_bool(patch) elif og_dtype == np.uint16: patch = skimage.img_as_uint(patch) elif og_dtype == np.int16: patch = skimage.img_as_int(patch) else: # just to straight cast, hope for the best patch_out = np.zeros(patch.shape, og_dtype) np.copyto(patch_out,patch) patch = patch_out # unscale if necessary if do_scale: patch *= scale_factor patch += minval return patch
