我们从Python开源项目中，提取了以下12个代码示例，用于说明如何使用scipy.inf()。
def glmnetSet(opts = None): import scipy # default options options = { "weights" : scipy.empty([0]), "offset" : scipy.empty([0]), "alpha" : scipy.float64(1.0), "nlambda" : scipy.int32(100), "lambda_min" : scipy.empty([0]), "lambdau" : scipy.empty([0]), "standardize" : True, "intr" : True, "thresh" : scipy.float64(1e-7), "dfmax" : scipy.empty([0]), "pmax" : scipy.empty([0]), "exclude" : scipy.empty([0], dtype = scipy.integer), "penalty_factor" : scipy.empty([0]), "cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]), "maxit" : scipy.int32(1e5), "gtype" : [], "ltype" : 'Newton', "standardize_resp" : False, "mtype" : 'ungrouped' } # quick return if no user opts if opts == None: print('pdco default options:') print(options) return options # if options are passed in by user, update options with values from opts optsInOptions = set(opts.keys()) - set(options.keys()); if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys print(optsInOptions, ' : unknown option for glmnetSet') raise ValueError('attempting to set glmnet options that are not known to glmnetSet') else: options = merge_dicts(options, opts) return options
def with_walking(time_arr, mins_per_square=1.3, transfer_constant=5): arr = time_arr.copy() cross_footprint = sp.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]).astype(bool) diag_footprint = sp.array([[1, 0, 1],[0, 1, 0], [1, 0, 1]]).astype(bool) arr[sp.isnan(arr)] = sp.inf for i in range(60): cross_arr = sp.ndimage.minimum_filter(arr, footprint=cross_footprint) cross_arr[sp.isnan(cross_arr)] = sp.inf cross_changes = (cross_arr != arr) cross_arr[cross_changes] += 1*mins_per_square diag_arr = sp.ndimage.minimum_filter(arr, footprint=diag_footprint) diag_arr[sp.isnan(diag_arr)] = sp.inf diag_changes = (diag_arr != arr) diag_arr[diag_changes] += 1.4*mins_per_square arr = sp.minimum(cross_arr, diag_arr) arr[sp.isinf(arr)] = sp.nan return arr + transfer_constant
def open_file(maindir): """ Creates the digital RF reading object. Args: maindir (:obj:'str'): The directory where the data is located. Returns: drfObj (obj:"DigitalRFReader"): Digital RF Reader object. chandict (obj:"dict"): Dictionary that holds info for the channels. start_indx (obj:'long'): Start index in samples. end_indx (obj:'long'): End index in samples. """ mainpath = os.path.expanduser(maindir) drfObj = drf.DigitalRFReader(mainpath) chans = drfObj.get_channels() chandict={} start_indx, end_indx=[0, sp.inf] # Get channel info for ichan in chans: curdict = {} curdict['sind'], curdict['eind'] = drfObj.get_bounds(ichan) # determine the read boundrys assuming the sampling is the same. start_indx = sp.maximum(curdict['sind'], start_indx) end_indx = sp.minimum(curdict['eind'], end_indx) dmetadict = drfObj.read_metadata(start_indx, end_indx, ichan) dmetakeys = dmetadict.keys() curdict['sps'] = dmetadict[dmetakeys[0]]['samples_per_second'] curdict['fo'] = dmetadict[dmetakeys[0]]['center_frequencies'].ravel()[0] chandict[ichan] = curdict return (drfObj, chandict, start_indx, end_indx)
def empty_mask(s1, s2): l1 = s1.shape[0] l2 = s2.shape[0] mask = sp.zeros((l1 + 1, l2 + 1)) mask[1:, 0] = sp.inf mask[0, 1:] = sp.inf return mask
def dtw_path(s1, s2): l1 = s1.shape[0] l2 = s2.shape[0] cum_sum = sp.zeros((l1 + 1, l2 + 1)) cum_sum[1:, 0] = sp.inf cum_sum[0, 1:] = sp.inf predecessors = [([None] * l2) for i in range(l1)] for i in range(l1): for j in range(l2): if sp.isfinite(cum_sum[i + 1, j + 1]): dij = sp.linalg.norm(s1[i] - s2[j]) ** 2 pred_list = [cum_sum[i, j + 1], cum_sum[i + 1, j], cum_sum[i, j]] argmin_pred = sp.argmin(pred_list) cum_sum[i + 1, j + 1] = pred_list[argmin_pred] + dij if i + j > 0: if argmin_pred == 0: predecessors[i][j] = (i - 1, j) elif argmin_pred == 1: predecessors[i][j] = (i, j - 1) else: predecessors[i][j] = (i - 1, j - 1) i = l1 - 1 j = l2 - 1 best_path = [(i, j)] while predecessors[i][j] is not None: i, j = predecessors[i][j] best_path.insert(0, (i, j)) return best_path
def __call__(self, x, y): return sum(abs((x[key]-y[key])/y[key]) if y[key] != 0 else (0 if x[key] == 0 else sp.inf) for key in self.measures_to_use) / len(self.measures_to_use)
def Tu( self, s=False, yr=False, myr=False, gyr=False ): return self.Th() * integrate.quad(self.Tfunc, 0, inf)[0] * self.timeConversion(s=s, yr=yr, myr=myr, gyr=gyr) # added 12/16/11 - Conor Mancone # returns conversion from arcseconds to physical angular size
def binHisto(data, verbose=False): """ Calculates bin width and number of bins for histogram using Freedman-Diaconis rule, if rule fails, defaults to square-root method The Freedman-Diaconis method is detailed in: Freedman, D., and P. Diaconis (1981), On the histogram as a density estimator: L2 theory, Z. Wahrscheinlichkeitstheor. Verw. Geb., 57, 453–476 and is also described by: Wilks, D. S. (2006), Statistical Methods in the Atmospheric Sciences, 2nd ed. Parameters ========== data : array_like list/array of data values verbose : boolean (optional) print out some more information Returns ======= out : tuple calculated width of bins using F-D rule, number of bins (nearest integer) to use for histogram Examples ======== >>> import numpy, spacepy >>> import matplotlib.pyplot as plt >>> numpy.random.seed(8675301) >>> data = numpy.random.randn(1000) >>> binw, nbins = spacepy.toolbox.binHisto(data) >>> print(nbins) 19.0 >>> p = plt.hist(data, bins=nbins, histtype='step', normed=True) See Also ======== matplotlib.pyplot.hist """ from matplotlib.mlab import prctile pul = prctile(data, p=(25,75)) #get confidence interval ql, qu = pul[0], pul[1] iqr = qu-ql binw = 2.*iqr/(len(data)**(1./3.)) if binw != 0: nbins = round((max(data)-min(data))/binw) # if nbins is 0, NaN or inf don't use the F-D rule just use sqrt(num) rule if binw == 0 or nbins == 0 or not np.isfinite(nbins): nbins = round(np.sqrt(len(data))) binw = len(data)/nbins if verbose: print("Used sqrt rule") else: if verbose: print("Used F-D rule") return (binw, nbins)
def dist_to_list(func, length, min=None, max=None): """ Convert a probability distribution function to a list of values This is a deterministic way to produce a known-length list of values matching a certain probability distribution. It is likely to be a closer match to the distribution function than a random sampling from the distribution. Parameters ========== func : callable function to call for each possible value, returning probability density at that value (does not need to be normalized.) length : int number of elements to return min : float minimum value to possibly include max : float maximum value to possibly include Examples ======== >>> import matplotlib >>> import numpy >>> import spacepy.toolbox as tb >>> gauss = lambda x: math.exp(-(x ** 2) / (2 * 5 ** 2)) / (5 * math.sqrt(2 * math.pi)) >>> vals = tb.dist_to_list(gauss, 1000, -numpy.inf, numpy.inf) >>> print vals[0] -16.45263... >>> p1 = matplotlib.pyplot.hist(vals, bins=[i - 10 for i in range(21)], facecolor='green') >>> matplotlib.pyplot.hold(True) >>> x = [i / 100.0 - 10.0 for i in range(2001)] >>> p2 = matplotlib.pyplot.plot(x, [gauss(i) * 1000 for i in x], 'red') >>> matplotlib.pyplot.draw() """ from scipy import inf from scipy.integrate import quad if min is None: min = -inf if max is None: max = inf total = quad(func, min, max)[0] step = float(total) / length return [intsolve(func, (0.5 + i) * step, min, max) for i in range(length)]
