我们从Python开源项目中，提取了以下33个代码示例，用于说明如何使用numpy.frompyfunc()。
def set_ufunc(self, scalar_op): # This is probably a speed up of the implementation if isinstance(scalar_op, theano.scalar.basic.Add): self.ufunc = numpy.add elif isinstance(scalar_op, theano.scalar.basic.Mul): self.ufunc = numpy.multiply elif isinstance(scalar_op, theano.scalar.basic.Maximum): self.ufunc = numpy.maximum elif isinstance(scalar_op, theano.scalar.basic.Minimum): self.ufunc = numpy.minimum elif isinstance(scalar_op, theano.scalar.basic.AND): self.ufunc = numpy.bitwise_and elif isinstance(scalar_op, theano.scalar.basic.OR): self.ufunc = numpy.bitwise_or elif isinstance(scalar_op, theano.scalar.basic.XOR): self.ufunc = numpy.bitwise_xor else: self.ufunc = numpy.frompyfunc(scalar_op.impl, 2, 1)
def _KeenerMatrix(self, A, C, regularization, func, epsilon): """func is a regularization function imposed on every element of matrix. """ # Apply Laplace Law B = A+A.T+2; A = A+1 A = A/B # Regularization if func is not None: h = np.frompyfunc(func, 1, 1) A = np.require(h(A), dtype=np.float32) # divide by contest number C = C+C.T c = np.sum(C, axis=1) if regularization: A = A/np.expand_dims(c, axis=1) A[C==0]=0 if epsilon is not None: A += epsilon*np.ones(A.shape, A.dtype) return A
def ztnb_pmf(y, mu, alpha): r = 1.0 / alpha if y <= 0: raise Exception('y must be larger than 0.') p = mu/(mu+r+0.0) ztnbin_mpmath = lambda y, p, r: mpmath.gamma(y + r)/(mpmath.gamma(y+1)*mpmath.gamma(r))*np.power(1-p, r)*np.power(p, y)/(1-np.power(1-p, r)) ztnbin = np.frompyfunc(ztnbin_mpmath, 3, 1) return float(ztnbin(y, p, r))
def test_frompyfunc_endian(self, level=rlevel): # Ticket #503 from math import radians uradians = np.frompyfunc(radians, 1, 1) big_endian = np.array([83.4, 83.5], dtype='>f8') little_endian = np.array([83.4, 83.5], dtype='<f8') assert_almost_equal(uradians(big_endian).astype(float), uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self): # gh-5672 def passer(*args): pass assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self): # gh-2014 def f(x): x[0], x[-1] = x[-1], x[0] uf = np.frompyfunc(f, 1, 0) a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]]) assert_equal(uf(a), ()) assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def _maybe_convert(values, val_kind, encoding): if _need_convert(val_kind): conv = _get_converter(val_kind, encoding) # conv = np.frompyfunc(conv, 1, 1) values = conv(values) return values
def draw_mandelbrot(cx, cy, d): """ ???(cx, cy)????d????Mandelbrot """ x0, x1, y0, y1 = cx-d, cx+d, cy-d, cy+d y, x = np.ogrid[y0:y1:200j, x0:x1:200j] c = x + y*1j start = time.clock() mandelbrot = np.frompyfunc(iter_point,1,1)(c).astype(np.float) print("time=",time.clock() - start) pl.imshow(mandelbrot, cmap=cm.jet, extent=[x0,x1,y0,y1]) #pl.gca().set_axis_off()
def __setstate__(self, d): super(Elemwise, self).__setstate__(d) self.ufunc = None self.nfunc = None if getattr(self, 'nfunc_spec', None): self.nfunc = getattr(numpy, self.nfunc_spec[0]) elif 0 < self.scalar_op.nin < 32: self.ufunc = numpy.frompyfunc(self.scalar_op.impl, self.scalar_op.nin, self.scalar_op.nout) self._rehash()
def compute_optimal_scales(self): """Form a set of scales to use in the wavelet transform. For non-orthogonal wavelet analysis, one can use an arbitrary set of scales. It is convenient to write the scales as fractional powers of two: s_j = s_0 * 2 ** (j * dj), j = 0, 1, ..., J J = (1 / dj) * log2(N * dt / s_0) s0 - smallest resolvable scale J - largest scale choose s0 so that the equivalent Fourier period is 2 * dt. The choice of dj depends on the width in spectral space of the wavelet function. For the morlet, dj=0.5 is the largest that still adequately samples scale. Smaller dj gives finer scale resolution. """ dt = self.dt # resolution dj = self.dj # smallest resolvable scale, chosen so that the equivalent # fourier period is approximately 2dt s0 = self.s0 # Largest scale J = int((1 / dj) * np.log2(self.N * dt / s0)) sj = s0 * 2 ** (dj * np.arange(0, J + 1)) return sj # TODO: use np.frompyfunc on this # TODO: can we just replace it with fftfreqs?
def __init__(self, p = 0.1, r = 10): nbin_mpmath = lambda k, p, r: mpmath.gamma(k + r)/(mpmath.gamma(k+1)\ *mpmath.gamma(r))*np.power(1-p, r)*np.power(p, k) self.nbin = np.frompyfunc(nbin_mpmath, 3, 1) self.p = p self.r = r
def transform(self,X): """ ?????: ???0?n-1???????????-1? X: ?????????DataFrame??Series? ???????????????????DataFrame??Series? """ data=X.copy() if isinstance(data,np.ndarray): if isinstance(self.fill_na,str): raise Exception('numpy?????????????') if not self.return_numeric: warnings.warn('numpy????????????????????????dataframe?series?') if not self.return_numeric: newlabel=self.get_label() if len(data.shape)==1: tmp=np.searchsorted(self.cuts,data).astype(int) result=np.where(np.isnan(data),-1,tmp) if (not self.return_numeric) and (not isinstance(data,np.ndarray)): f=np.frompyfunc(lambda xx: newlabel.get(xx,self.fill_na),1,1) result=f(result) if isinstance(data,np.ndarray): result[result==-1]=self.fill_na else: result=pd.Series(result) result.index=data.index result.index.name=data.index.name result.name=data.name result[result==-1]=self.fill_na data=result.copy() else: for feature in self.cuts: if not isinstance(data,pd.DataFrame): tmp=np.searchsorted(self.cuts[feature],data[:,feature]).astype(int) data[:,feature]=np.where(np.isnan(data[:,feature]),self.fill_na,tmp) else: tmp=np.searchsorted(self.cuts[feature],data[feature]).astype(int) data[feature]=np.where(np.isnan(data[feature]),-1,tmp) if not self.return_numeric: f=np.frompyfunc(lambda xx: newlabel[feature].get(xx,self.fill_na),1,1) data[feature]=f(data[feature]) else: data.loc[data[feature]==-1,feature]=self.fill_na if self.return_array and isinstance(data,(pd.Series,pd.DataFrame)): return data.values else: return data
def prepare_node(self, node, storage_map, compute_map, impl): # Postpone the ufunc building to the last minutes # NumPy ufunc support only up to 31 inputs. # But our c code support more. if (len(node.inputs) < 32 and (self.nfunc is None or self.scalar_op.nin != len(node.inputs)) and self.ufunc is None and impl == 'py'): ufunc = numpy.frompyfunc(self.scalar_op.impl, len(node.inputs), self.scalar_op.nout) if self.scalar_op.nin > 0: # We can reuse it for many nodes self.ufunc = ufunc else: node.tag.ufunc = ufunc # Numpy ufuncs will sometimes perform operations in # float16, in particular when the input is int8. # This is not something that we want, and we do not # do it in the C code, so we specify that the computation # should be carried out in the returned dtype. # This is done via the "sig" kwarg of the ufunc, its value # should be something like "ff->f", where the characters # represent the dtype of the inputs and outputs. # NumPy 1.10.1 raise an error when giving the signature # when the input is complex. So add it only when inputs is int. out_dtype = node.outputs[0].dtype if (out_dtype in float_dtypes and isinstance(self.nfunc, numpy.ufunc) and node.inputs[0].dtype in discrete_dtypes): char = numpy.sctype2char(out_dtype) sig = char * node.nin + '->' + char * node.nout node.tag.sig = sig node.tag.fake_node = Apply( self.scalar_op, [get_scalar_type(dtype=input.type.dtype).make_variable() for input in node.inputs], [get_scalar_type(dtype=output.type.dtype).make_variable() for output in node.outputs]) self.scalar_op.prepare_node(node.tag.fake_node, None, None, impl)
def perform(self, node, inp, out): input, = inp output, = out axis = self.axis if axis is None: axis = list(range(input.ndim)) variable = input to_reduce = reversed(sorted(axis)) if hasattr(self, 'acc_dtype') and self.acc_dtype is not None: acc_dtype = self.acc_dtype else: acc_dtype = node.outputs[0].type.dtype if to_reduce: for dimension in to_reduce: # If it's a zero-size array, use scalar_op.identity # if available if variable.shape[dimension] == 0: if hasattr(self.scalar_op, 'identity'): # Compute the shape of the output v_shape = list(variable.shape) del v_shape[dimension] variable = numpy.empty(tuple(v_shape), dtype=acc_dtype) variable.fill(self.scalar_op.identity) else: raise ValueError(( "Input (%s) has zero-size on axis %s, but " "self.scalar_op (%s) has no attribute 'identity'" % (variable, dimension, self.scalar_op))) else: # Numpy 1.6 has a bug where you sometimes have to specify # "dtype='object'" in reduce for it to work, if the ufunc # was built with "frompyfunc". We need to find out if we # are in one of these cases (only "object" is supported in # the output). if ((self.ufunc.ntypes == 1) and (self.ufunc.types[0][-1] == 'O')): variable = self.ufunc.reduce(variable, dimension, dtype='object') else: variable = self.ufunc.reduce(variable, dimension, dtype=acc_dtype) variable = numpy.asarray(variable) if numpy.may_share_memory(variable, input): # perhaps numpy is clever for reductions of size 1? # We don't want this. variable = variable.copy() output[0] = theano._asarray(variable, dtype=node.outputs[0].type.dtype) else: # Force a copy output[0] = numpy.array(variable, copy=True, dtype=node.outputs[0].type.dtype)
