Datasets:

h4iku
/

coconut_python2010_preprocessed

Dataset card Viewer Files Files and versions Community

Split (1)

train · 303k rows

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
	def _cdf_single_call(self, x, *args): return scipy.integrate.quad(self._pdf, self.a, x, args=args)[0]	def _rvs(self, args): ## Use basic inverse cdf algorithm for RV generation as default. U = rand.sample(self._size) Y = self._ppf(U,args) return Y
return scipy.integrate.quad(self._pdf, self.a, x, args=args)[0]	return self.veccdf(x,*args)	def _cdf(self, x, *args): return scipy.integrate.quad(self._pdf, self.a, x, args=args)[0]
insert(output,(1-cond0)*(cond1==cond1), self.badvalue)	insert(output,(1-cond0)+(1-cond1)*(q!=0.0), self.badvalue)	def ppf(self,q,args,*kwds): """Percent point function (inverse of cdf) at q of the given RV.
self._cdfvec = sgf(self._cdfsingle)	self._cdfvec = sgf(self._cdfsingle,otypes='d')	def __init__(self, a=0, b=scipy.inf, name=None, badvalue=None, moment_tol=1e-8,values=None,inc=1,longname=None, shapes=None, extradoc=None): if badvalue is None: badvalue = scipy.nan self.badvalue = badvalue self.a = a self.b = b self.invcdf_a = a self.invcdf_b = b self.name = name self.moment_tol = moment_tol self.inc = inc self._cdfvec = sgf(self._cdfsingle) self.return_integers = 1 self.vecentropy = vectorize(self._entropy)
self._ppf = new.instancemethod(sgf(_drv_ppf), self, rv_discrete) self._pmf = new.instancemethod(sgf(_drv_pmf), self, rv_discrete) self._cdf = new.instancemethod(sgf(_drv_cdf), self, rv_discrete)	self._ppf = new.instancemethod(sgf(_drv_ppf,otypes='d'), self, rv_discrete) self._pmf = new.instancemethod(sgf(_drv_pmf,otypes='d'), self, rv_discrete) self._cdf = new.instancemethod(sgf(_drv_cdf,otypes='d'), self, rv_discrete)	def __init__(self, a=0, b=scipy.inf, name=None, badvalue=None, moment_tol=1e-8,values=None,inc=1,longname=None, shapes=None, extradoc=None): if badvalue is None: badvalue = scipy.nan self.badvalue = badvalue self.a = a self.b = b self.invcdf_a = a self.invcdf_b = b self.name = name self.moment_tol = moment_tol self.inc = inc self._cdfvec = sgf(self._cdfsingle) self.return_integers = 1 self.vecentropy = vectorize(self._entropy)
self._vecppf = new.instancemethod(sgf(_drv2_ppfsingle),	self._vecppf = new.instancemethod(sgf(_drv2_ppfsingle,otypes='d'),	def __init__(self, a=0, b=scipy.inf, name=None, badvalue=None, moment_tol=1e-8,values=None,inc=1,longname=None, shapes=None, extradoc=None): if badvalue is None: badvalue = scipy.nan self.badvalue = badvalue self.a = a self.b = b self.invcdf_a = a self.invcdf_b = b self.name = name self.moment_tol = moment_tol self.inc = inc self._cdfvec = sgf(self._cdfsingle) self.return_integers = 1 self.vecentropy = vectorize(self._entropy)
self.generic_moment = new.instancemethod(sgf(_drv2_moment),	self.generic_moment = new.instancemethod(sgf(_drv2_moment, otypes='d'),	def __init__(self, a=0, b=scipy.inf, name=None, badvalue=None, moment_tol=1e-8,values=None,inc=1,longname=None, shapes=None, extradoc=None): if badvalue is None: badvalue = scipy.nan self.badvalue = badvalue self.a = a self.b = b self.invcdf_a = a self.invcdf_b = b self.name = name self.moment_tol = moment_tol self.inc = inc self._cdfvec = sgf(self._cdfsingle) self.return_integers = 1 self.vecentropy = vectorize(self._entropy)
Numeric_solve = linalg.solve_linear_equations	basic_solve = linalg.solve_linear_equations	def bench_random(self,level=5): from scipy.basic import linalg Numeric_solve = linalg.solve_linear_equations print print ' Solving system of linear equations' print ' =================================='
assert not a.iscontiguous()	assert not a.flags['CONTIGUOUS']	def bench_random(self,level=5): from scipy.basic import linalg Numeric_solve = linalg.solve_linear_equations print print ' Solving system of linear equations' print ' =================================='
Numeric_inv = linalg.inverse	basic_inv = linalg.inverse	def bench_random(self,level=5): from scipy.basic import linalg Numeric_inv = linalg.inverse print print ' Finding matrix inverse' print ' ==================================' print ' \| contiguous \| non-contiguous ' print '----------------------------------------------' print ' size \| scipy \| basic \| scipy \| basic' for size,repeat in [(20,1000),(100,150),(500,2),(1000,1)][:-1]: repeat = 2 print '%5s' % size, sys.stdout.flush() a = random([size,size]) # large diagonal ensures non-singularity: for i in range(size): a[i,i] = 10(.1+a[i,i])
assert not a.iscontiguous()	assert not a.flags['CONTIGUOUS']	def bench_random(self,level=5): from scipy.basic import linalg Numeric_inv = linalg.inverse print print ' Finding matrix inverse' print ' ==================================' print ' \| contiguous \| non-contiguous ' print '----------------------------------------------' print ' size \| scipy \| basic \| scipy \| basic' for size,repeat in [(20,1000),(100,150),(500,2),(1000,1)][:-1]: repeat = 2 print '%5s' % size, sys.stdout.flush() a = random([size,size]) # large diagonal ensures non-singularity: for i in range(size): a[i,i] = 10(.1+a[i,i])
Numeric_det = linalg.determinant	basic_det = linalg.determinant	def check_random(self): from scipy.basic import linalg Numeric_det = linalg.determinant n = 20 for i in range(4): a = random([n,n]) d1 = det(a) d2 = Numeric_det(a) assert_almost_equal(d1,d2)
d2 = Numeric_det(a)	d2 = basic_det(a)	def check_random(self): from scipy.basic import linalg Numeric_det = linalg.determinant n = 20 for i in range(4): a = random([n,n]) d1 = det(a) d2 = Numeric_det(a) assert_almost_equal(d1,d2)
Numeric_det = linalg.determinant	basic_det = linalg.determinant	def check_random_complex(self): from scipy.basic import linalg Numeric_det = linalg.determinant n = 20 for i in range(4): a = random([n,n]) + 2j*random([n,n]) d1 = det(a) d2 = Numeric_det(a) assert_almost_equal(d1,d2)
d2 = Numeric_det(a)	d2 = basic_det(a)	def check_random_complex(self): from scipy.basic import linalg Numeric_det = linalg.determinant n = 20 for i in range(4): a = random([n,n]) + 2j*random([n,n]) d1 = det(a) d2 = Numeric_det(a) assert_almost_equal(d1,d2)
Numeric_det = linalg.determinant	basic_det = linalg.determinant	def bench_random(self,level=5): from scipy.basic import linalg Numeric_det = linalg.determinant print print ' Finding matrix determinant' print ' ==================================' print ' \| contiguous \| non-contiguous ' print '----------------------------------------------' print ' size \| scipy \| basic \| scipy \| basic ' for size,repeat in [(20,1000),(100,150),(500,2),(1000,1)][:-1]: repeat *= 2 print '%5s' % size, sys.stdout.flush() a = random([size,size])
assert not a.iscontiguous()	assert not a.flags['CONTIGUOUS']	def bench_random(self,level=5): from scipy.basic import linalg Numeric_det = linalg.determinant print print ' Finding matrix determinant' print ' ==================================' print ' \| contiguous \| non-contiguous ' print '----------------------------------------------' print ' size \| scipy \| basic \| scipy \| basic ' for size,repeat in [(20,1000),(100,150),(500,2),(1000,1)][:-1]: repeat *= 2 print '%5s' % size, sys.stdout.flush() a = random([size,size])
indx = cols[:,newaxis]ones((1,rN)) + \ rows[newaxis,:]ones((cN,1)) - 1	indx = cols[:,newaxis]ones((1,rN),dtype=int) + \ rows[newaxis,:]ones((cN,1),dtype=int) - 1	def toeplitz(c,r=None): """ Construct a toeplitz matrix (i.e. a matrix with constant diagonals). Description: toeplitz(c,r) is a non-symmetric Toeplitz matrix with c as its first column and r as its first row. toeplitz(c) is a symmetric (Hermitian) Toeplitz matrix (r=c). See also: hankel """ isscalar = numpy.isscalar if isscalar(c) or isscalar(r): return c if r is None: r = c r[0] = conjugate(r[0]) c = conjugate(c) r,c = map(asarray_chkfinite,(r,c)) r,c = map(ravel,(r,c)) rN,cN = map(len,(r,c)) if r[0] != c[0]: print "Warning: column and row values don't agree; column value used." vals = r_[r[rN-1:0:-1], c] cols = mgrid[0:cN] rows = mgrid[rN:0:-1] indx = cols[:,newaxis]ones((1,rN)) + \ rows[newaxis,:]ones((cN,1)) - 1 return take(vals, indx)
indx = cols[:,newaxis]ones((1,rN)) + \ rows[newaxis,:]ones((cN,1)) - 1	indx = cols[:,newaxis]ones((1,rN),dtype=int) + \ rows[newaxis,:]ones((cN,1),dtype=int) - 1	def hankel(c,r=None): """ Construct a hankel matrix (i.e. matrix with constant anti-diagonals). Description: hankel(c,r) is a Hankel matrix whose first column is c and whose last row is r. hankel(c) is a square Hankel matrix whose first column is C. Elements below the first anti-diagonal are zero. See also: toeplitz """ isscalar = numpy.isscalar if isscalar(c) or isscalar(r): return c if r is None: r = zeros(len(c)) elif r[0] != c[-1]: print "Warning: column and row values don't agree; column value used." r,c = map(asarray_chkfinite,(r,c)) r,c = map(ravel,(r,c)) rN,cN = map(len,(r,c)) vals = r_[c, r[1:rN]] cols = mgrid[1:cN+1] rows = mgrid[0:rN] indx = cols[:,newaxis]ones((1,rN)) + \ rows[newaxis,:]ones((cN,1)) - 1 return take(vals, indx)
lfit = Results(L.lstsq(self.wdesign, Z)[0])	lfit = Results(L.lstsq(self.wdesign, Z)[0], Y)	def est_coef(self, Y): """ Estimate coefficients using lstsq, returning fitted values, Y and coefficients, but initialize is not called so no psuedo-inverse is calculated. """ Z = self.whiten(Y)
lfit.Y = Y		def est_coef(self, Y): """ Estimate coefficients using lstsq, returning fitted values, Y and coefficients, but initialize is not called so no psuedo-inverse is calculated. """ Z = self.whiten(Y)
lfit = Results(N.dot(self.calc_beta, Z),	lfit = Results(N.dot(self.calc_beta, Z), Y,	def fit(self, Y, **keywords): """ Full \'fit\' of the model including estimate of covariance matrix, (whitened) residuals and scale.
lfit.Y = Y		def fit(self, Y, **keywords): """ Full \'fit\' of the model including estimate of covariance matrix, (whitened) residuals and scale.
norm_resid = self.resid * N.multiply.outer(N.ones(Y.shape[0]), sdd)	norm_resid = self.resid * N.multiply.outer(N.ones(self.Y.shape[0]), sdd)	def norm_resid(self): """ Residuals, normalized to have unit length.
if not adjusted: ratio *= ((Y.shape[0] - 1) / self.df_resid)	if not adjusted: ratio *= ((self.Y.shape[0] - 1) / self.df_resid)	def Rsq(self, adjusted=False): """ Return the R^2 value for each row of the response Y. """ self.Ssq = N.std(self.Z,axis=0)*2 ratio = self.scale / self.Ssq if not adjusted: ratio = ((Y.shape[0] - 1) / self.df_resid) return 1 - ratio
from scipy.misc import _common_type ct = _common_type(obs,code_book)	from scipy.misc import x_common_type ct = x_common_type(obs,code_book)	def vq(obs,code_book): """ Vector Quantization: assign features sets to codes in a code book. Description: Vector quantization determines which code in the code book best represents an observation of a target. The features of each observation are compared to each code in the book, and assigned the one closest to it. The observations are contained in the obs array. These features should be "whitened," or nomalized by the standard deviation of all the features before being quantized. The code book can be created using the kmeans algorithm or something similar. Note: This currently forces 32 bit math precision for speed. Anyone know of a situation where this undermines the accuracy of the algorithm? Arguments: obs -- 2D array. Each row of the array is an observation. The columns are the "features" seen during each observation The features must be whitened first using the whiten function or something equivalent. code_book -- 2D array. The code book is usually generated using the kmeans algorithm. Each row of the array holds a different code, and the columns are the features of the code. # c0 c1 c2 c3 code_book = [[ 1., 2., 3., 4.], #f0 [ 1., 2., 3., 4.], #f1 [ 1., 2., 3., 4.]]) #f2 Outputs: code -- 1D array. If obs is a NxM array, then a length M array is returned that holds the selected code book index for each observation. dist -- 1D array. The distortion (distance) between the observation and its nearest code Reference Test >>> code_book = array([[1.,1.,1.], ... [2.,2.,2.]]) >>> features = array([[ 1.9,2.3,1.7], ... [ 1.5,2.5,2.2], ... [ 0.8,0.6,1.7]]) >>> vq(features,code_book) (array([1, 1, 0],'i'), array([ 0.43588989, 0.73484692, 0.83066239])) """ try: import _vq from scipy.misc import _common_type ct = _common_type(obs,code_book) c_obs = obs.astype(ct) c_code_book = code_book.astype(ct) if ct == 'f': results = _vq.float_vq(c_obs,c_code_book) elif ct == 'd': results = _vq.double_vq(c_obs,c_code_book) else: results = py_vq(obs,code_book) except ImportError: print 'py' results = py_vq(obs,code_book) return results
print 'py'		def vq(obs,code_book): """ Vector Quantization: assign features sets to codes in a code book. Description: Vector quantization determines which code in the code book best represents an observation of a target. The features of each observation are compared to each code in the book, and assigned the one closest to it. The observations are contained in the obs array. These features should be "whitened," or nomalized by the standard deviation of all the features before being quantized. The code book can be created using the kmeans algorithm or something similar. Note: This currently forces 32 bit math precision for speed. Anyone know of a situation where this undermines the accuracy of the algorithm? Arguments: obs -- 2D array. Each row of the array is an observation. The columns are the "features" seen during each observation The features must be whitened first using the whiten function or something equivalent. code_book -- 2D array. The code book is usually generated using the kmeans algorithm. Each row of the array holds a different code, and the columns are the features of the code. # c0 c1 c2 c3 code_book = [[ 1., 2., 3., 4.], #f0 [ 1., 2., 3., 4.], #f1 [ 1., 2., 3., 4.]]) #f2 Outputs: code -- 1D array. If obs is a NxM array, then a length M array is returned that holds the selected code book index for each observation. dist -- 1D array. The distortion (distance) between the observation and its nearest code Reference Test >>> code_book = array([[1.,1.,1.], ... [2.,2.,2.]]) >>> features = array([[ 1.9,2.3,1.7], ... [ 1.5,2.5,2.2], ... [ 0.8,0.6,1.7]]) >>> vq(features,code_book) (array([1, 1, 0],'i'), array([ 0.43588989, 0.73484692, 0.83066239])) """ try: import _vq from scipy.misc import _common_type ct = _common_type(obs,code_book) c_obs = obs.astype(ct) c_code_book = code_book.astype(ct) if ct == 'f': results = _vq.float_vq(c_obs,c_code_book) elif ct == 'd': results = _vq.double_vq(c_obs,c_code_book) else: results = py_vq(obs,code_book) except ImportError: print 'py' results = py_vq(obs,code_book) return results
im = asarray(im)	im = MLab.asarray(im)	def wiener(im,mysize=None,noise=None): """Perform a wiener filter on an N-dimensional array. Description: Apply a wiener filter to the N-dimensional array in. Inputs: in -- an N-dimensional array. kernel_size -- A scalar or an N-length list giving the size of the median filter window in each dimension. Elements of kernel_size should be odd. If kernel_size is a scalar, then this scalar is used as the size in each dimension. noise -- The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Outputs: (out,) out -- Wiener filtered result with the same shape as in. """ im = asarray(im) if mysize == None: mysize = [3] * len(im.shape) mysize = MLab.asarray(mysize); # Estimate the local mean lMean = correlate(im,ones(mysize),1) / MLab.prod(mysize) # Estimate the local variance lVar = correlate(im2,ones(mysize),1) / MLab.prod(mysize) - lMean2 # Estimate the noise power if needed. if noise==None: noise = MLab.mean(ravel(lVar)) # Compute result # f = lMean + (maximum(0, lVar - noise) ./ # maximum(lVar, noise)) * (im - lMean) # out = im - lMean im = lVar - noise im = MLab.maximum(im,0) lVar = MLab.maximum(lVar,noise) out = out / lVar out = out * im out = out + lMean return out
lMean = correlate(im,ones(mysize),1) / MLab.prod(mysize)	lMean = correlate(im,MLab.ones(mysize),1) / MLab.prod(mysize)	def wiener(im,mysize=None,noise=None): """Perform a wiener filter on an N-dimensional array. Description: Apply a wiener filter to the N-dimensional array in. Inputs: in -- an N-dimensional array. kernel_size -- A scalar or an N-length list giving the size of the median filter window in each dimension. Elements of kernel_size should be odd. If kernel_size is a scalar, then this scalar is used as the size in each dimension. noise -- The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Outputs: (out,) out -- Wiener filtered result with the same shape as in. """ im = asarray(im) if mysize == None: mysize = [3] * len(im.shape) mysize = MLab.asarray(mysize); # Estimate the local mean lMean = correlate(im,ones(mysize),1) / MLab.prod(mysize) # Estimate the local variance lVar = correlate(im2,ones(mysize),1) / MLab.prod(mysize) - lMean2 # Estimate the noise power if needed. if noise==None: noise = MLab.mean(ravel(lVar)) # Compute result # f = lMean + (maximum(0, lVar - noise) ./ # maximum(lVar, noise)) * (im - lMean) # out = im - lMean im = lVar - noise im = MLab.maximum(im,0) lVar = MLab.maximum(lVar,noise) out = out / lVar out = out * im out = out + lMean return out
lVar = correlate(im2,ones(mysize),1) / MLab.prod(mysize) - lMean2	lVar = correlate(im2,MLab.ones(mysize),1) / MLab.prod(mysize) - lMean2	def wiener(im,mysize=None,noise=None): """Perform a wiener filter on an N-dimensional array. Description: Apply a wiener filter to the N-dimensional array in. Inputs: in -- an N-dimensional array. kernel_size -- A scalar or an N-length list giving the size of the median filter window in each dimension. Elements of kernel_size should be odd. If kernel_size is a scalar, then this scalar is used as the size in each dimension. noise -- The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Outputs: (out,) out -- Wiener filtered result with the same shape as in. """ im = asarray(im) if mysize == None: mysize = [3] * len(im.shape) mysize = MLab.asarray(mysize); # Estimate the local mean lMean = correlate(im,ones(mysize),1) / MLab.prod(mysize) # Estimate the local variance lVar = correlate(im2,ones(mysize),1) / MLab.prod(mysize) - lMean2 # Estimate the noise power if needed. if noise==None: noise = MLab.mean(ravel(lVar)) # Compute result # f = lMean + (maximum(0, lVar - noise) ./ # maximum(lVar, noise)) * (im - lMean) # out = im - lMean im = lVar - noise im = MLab.maximum(im,0) lVar = MLab.maximum(lVar,noise) out = out / lVar out = out * im out = out + lMean return out
noise = MLab.mean(ravel(lVar))	noise = MLab.mean(MLab.ravel(lVar))	def wiener(im,mysize=None,noise=None): """Perform a wiener filter on an N-dimensional array. Description: Apply a wiener filter to the N-dimensional array in. Inputs: in -- an N-dimensional array. kernel_size -- A scalar or an N-length list giving the size of the median filter window in each dimension. Elements of kernel_size should be odd. If kernel_size is a scalar, then this scalar is used as the size in each dimension. noise -- The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Outputs: (out,) out -- Wiener filtered result with the same shape as in. """ im = asarray(im) if mysize == None: mysize = [3] * len(im.shape) mysize = MLab.asarray(mysize); # Estimate the local mean lMean = correlate(im,ones(mysize),1) / MLab.prod(mysize) # Estimate the local variance lVar = correlate(im2,ones(mysize),1) / MLab.prod(mysize) - lMean2 # Estimate the noise power if needed. if noise==None: noise = MLab.mean(ravel(lVar)) # Compute result # f = lMean + (maximum(0, lVar - noise) ./ # maximum(lVar, noise)) * (im - lMean) # out = im - lMean im = lVar - noise im = MLab.maximum(im,0) lVar = MLab.maximum(lVar,noise) out = out / lVar out = out * im out = out + lMean return out
gist.plsys(savesys)	if savesys > 0: gist.plsys(savesys)	def plot(x,args,*keywds): """Plot curves. Description: Plot one or more curves on the same graph. Inputs: There can be a variable number of inputs which consist of pairs or triples. The second variable is plotted against the first using the linetype specified by the optional third variable in the triple. If only two plots are being compared, the x-axis does not have to be repeated. """ try: override = 1 savesys = gist.plsys(2) gist.plsys(savesys) except: override = 0 global _hold try: _hold=keywds['hold'] except KeyError: pass try: linewidth=float(keywds['width']) except KeyError: linewidth=1.0 if _hold or override: pass else: gist.fma() gist.animate(0) savesys = gist.plsys() winnum = gist.window() if winnum < 0: gist.window(0) gist.plsys(savesys) nargs = len(args) if nargs == 0: y = scipy.squeeze(x) x = Numeric.arange(0,len(y)) if scipy.iscomplexobj(y): print "Warning: complex data plotting real part." y = y.real y = where(scipy.isfinite(y),y,0) gist.plg(y,x,type='solid',color='blue',marks=0,width=linewidth) return y = args[0] argpos = 1 nowplotting = 0 clear_global_linetype() while 1: try: thearg = args[argpos] except IndexError: thearg = 0 thetype,thecolor,themarker,tomark = _parse_type_arg(thearg,nowplotting) if themarker == 'Z': # args[argpos] was data or non-existent. pass append_global_linetype(_rtypes[thetype]+_rcolors[thecolor]) else: # args[argpos] was a string argpos = argpos + 1 if tomark: append_global_linetype(_rtypes[thetype]+_rcolors[thecolor]+_rmarkers[themarker]) else: append_global_linetype(_rtypes[thetype]+_rcolors[thecolor]) if scipy.iscomplexobj(x) or scipy.iscomplexobj(y): print "Warning: complex data provided, using only real part." x = scipy.real(x) y = scipy.real(y) y = where(scipy.isfinite(y),y,0) y = scipy.squeeze(y) x = scipy.squeeze(x) gist.plg(y,x,type=thetype,color=thecolor,marker=themarker,marks=tomark,width=linewidth) nowplotting = nowplotting + 1 ## Argpos is pointing to the next potential triple of data. ## Now one of four things can happen: ## ## 1: argpos points to data, argpos+1 is a string ## 2: argpos points to data, end ## 3: argpos points to data, argpos+1 is data ## 4: argpos points to data, argpos+1 is data, argpos+2 is a string if argpos >= nargs: break # no more data if argpos == nargs-1: # this is a single data value. x = x y = args[argpos] argpos = argpos+1 elif type(args[argpos+1]) is types.StringType: x = x y = args[argpos] argpos = argpos+1 else: # 3 x = args[argpos] y = args[argpos+1] argpos = argpos+2 return
[4, 0.5+4, 5./6+4, 1./9, (0.75)*4sqrt(pi)* gamma(5./6+2./34)/gamma(0.5+4./3)gamma(5./6+4./3)],	[5, 2, 5-2+1, -1, 1./2*5sqrt(pi)* gamma(1+5-2)/gamma(1+0.55-2)/gamma(0.5+0.55)], [4, 0.5+4, 1.5-24, -1./3, (8./9)(-24)gamma(4./3) gamma(1.5-24)/gamma(3./2)/gamma(4./3-24)],	def check_hyp2f1(self): # a collection of special cases taken from AMS 55 values = [[0.5, 1, 1.5, 0.2*2, 0.5/0.2log((1+0.2)/(1-0.2))], [0.5, 1, 1.5, -0.2*2, 1./0.2arctan(0.2)], [1, 1, 2, 0.2, -1/0.2log(1-0.2)], [3, 3.5, 1.5, 0.22, 0.5/0.2/(-5)((1+0.2)(-5)-(1-0.2)(-5))], [-3, 3, 0.5, sin(0.2)*2, cos(230.2)], [3, 4, 8, 1, gamma(8)gamma(8-4-3)/gamma(8-3)/gamma(8-4)], [3, 2, 3-2+1, -1, 1./2*3sqrt(pi)* gamma(1+3-2)/gamma(1+0.53-2)/gamma(0.5+0.53)], [4, 0.5+4, 5./6+4, 1./9, (0.75)*4sqrt(pi)* gamma(5./6+2./34)/gamma(0.5+4./3)gamma(5./6+4./3)], ] for i, (a, b, c, x, v) in enumerate(values): cv = hyp2f1(a, b, c, x) assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
[x,w] = P_roots(n)	[x,w] = p_roots(n)	def fixed_quad(func,a,b,args=(),n=5): """Compute a definite integral using fixed-order Gaussian quadrature. Description: Integrate func from a to b using Gaussian quadrature of order n. Inputs: func -- a Python function or method to integrate. a -- lower limit of integration b -- upper limit of integration args -- extra arguments to pass to function. n -- order of quadrature integration. Outputs: (val, None) val -- Gaussian quadrature approximation to the integral. """ [x,w] = P_roots(n) ainf, binf = map(scipy.isinf,(a,b)) if ainf or binf: raise ValueError, "Gaussian quadrature is only available for finite limits." y = (b-a)(x+1)/2.0 + a return (b-a)/2.0sum(wfunc(y,args)), None
return (kvp(v-1,z,n-1) - kvp(v+1,z,n-1))/2.0	return (kvp(v-1,z,n-1) + kvp(v+1,z,n-1))/(-2.0)	def kvp(v,z,n=1): """Return the nth derivative of Kv(z) with respect to z. """ if not isinstance(n,types.IntType) or (n<0): raise ValueError, "n must be a non-negative integer." if n == 0: return kv(v,z) else: return (kvp(v-1,z,n-1) - kvp(v+1,z,n-1))/2.0
return (ivp(v-1,z,n-1) - ivp(v+1,z,n-1))/2.0	return (ivp(v-1,z,n-1) + ivp(v+1,z,n-1))/2.0	def ivp(v,z,n=1): """Return the nth derivative of Iv(z) with respect to z. """ if not isinstance(n,types.IntType) or (n<0): raise ValueError, "n must be a non-negative integer." if n == 0: return iv(v,z) else: return (ivp(v-1,z,n-1) - ivp(v+1,z,n-1))/2.0
x0 = asarray(x0)	x0 = asfarray(x0)	def fmin(func, x0, args=(), xtol=1e-4, ftol=1e-4, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0): """Minimize a function using the downhill simplex algorithm. Description: Uses a Nelder-Mead simplex algorithm to find the minimum of function of one or more variables. Inputs: func -- the Python function or method to be minimized. x0 -- the initial guess. args -- extra arguments for func. Outputs: (xopt, {fopt, iter, funcalls, warnflag}) xopt -- minimizer of function fopt -- value of function at minimum: fopt = func(xopt) iter -- number of iterations funcalls -- number of function calls warnflag -- Integer warning flag: 1 : 'Maximum number of function evaluations.' 2 : 'Maximum number of iterations.' allvecs -- a list of solutions at each iteration Additional Inputs: xtol -- acceptable relative error in xopt for convergence. ftol -- acceptable relative error in func(xopt) for convergence. maxiter -- the maximum number of iterations to perform. maxfun -- the maximum number of function evaluations. full_output -- non-zero if fval and warnflag outputs are desired. disp -- non-zero to print convergence messages. retall -- non-zero to return list of solutions at each iteration """ x0 = asarray(x0) N = len(x0) rank = len(x0.shape) if not -1 < rank < 2: raise ValueError, "Initial guess must be a scalar or rank-1 sequence." if maxiter is None: maxiter = N * 200 if maxfun is None: maxfun = N * 200 rho = 1; chi = 2; psi = 0.5; sigma = 0.5; one2np1 = range(1,N+1) if rank == 0: sim = Num.zeros((N+1,),x0.typecode()) else: sim = Num.zeros((N+1,N),x0.typecode()) fsim = Num.zeros((N+1,),'d') sim[0] = x0 if retall: allvecs = [sim[0]] fsim[0] = apply(func,(x0,)+args) nonzdelt = 0.05 zdelt = 0.00025 for k in range(0,N): y = Num.array(x0,copy=1) if y[k] != 0: y[k] = (1+nonzdelt)y[k] else: y[k] = zdelt sim[k+1] = y f = apply(func,(y,)+args) fsim[k+1] = f ind = Num.argsort(fsim) fsim = Num.take(fsim,ind) # sort so sim[0,:] has the lowest function value sim = Num.take(sim,ind,0) iterations = 1 funcalls = N+1 while (funcalls < maxfun and iterations < maxiter): if (max(Num.ravel(abs(sim[1:]-sim[0]))) <= xtol \ and max(abs(fsim[0]-fsim[1:])) <= ftol): break xbar = Num.add.reduce(sim[:-1],0) / N xr = (1+rho)xbar - rhosim[-1] fxr = apply(func,(xr,)+args) funcalls = funcalls + 1 doshrink = 0 if fxr < fsim[0]: xe = (1+rhochi)xbar - rhochisim[-1] fxe = apply(func,(xe,)+args) funcalls = funcalls + 1 if fxe < fxr: sim[-1] = xe fsim[-1] = fxe else: sim[-1] = xr fsim[-1] = fxr else: # fsim[0] <= fxr if fxr < fsim[-2]: sim[-1] = xr fsim[-1] = fxr else: # fxr >= fsim[-2] # Perform contraction if fxr < fsim[-1]: xc = (1+psirho)xbar - psirhosim[-1] fxc = apply(func,(xc,)+args) funcalls = funcalls + 1 if fxc <= fxr: sim[-1] = xc fsim[-1] = fxc else: doshrink=1 else: # Perform an inside contraction xcc = (1-psi)xbar + psisim[-1] fxcc = apply(func,(xcc,)+args) funcalls = funcalls + 1 if fxcc < fsim[-1]: sim[-1] = xcc fsim[-1] = fxcc else: doshrink = 1 if doshrink: for j in one2np1: sim[j] = sim[0] + sigma(sim[j] - sim[0]) fsim[j] = apply(func,(sim[j],)+args) funcalls = funcalls + N ind = Num.argsort(fsim) sim = Num.take(sim,ind,0) fsim = Num.take(fsim,ind) iterations = iterations + 1 if retall: allvecs.append(sim[0]) x = sim[0] fval = min(fsim) warnflag = 0 if funcalls >= maxfun: warnflag = 1 if disp: print "Warning: Maximum number of function evaluations has "\ "been exceeded." elif iterations >= maxiter: warnflag = 2 if disp: print "Warning: Maximum number of iterations has been exceeded" else: if disp: print "Optimization terminated successfully." print " Current function value: %f" % fval print " Iterations: %d" % iterations print " Function evaluations: %d" % funcalls if full_output: retlist = x, fval, iterations, funcalls, warnflag if retall: retlist += (allvecs,) else: retlist = x if retall: retlist = (x, allvecs) return retlist
extra_args = (func, p, xi) + args	extra_args = (func, p, xi, args)	def _linesearch_powell(func, p, xi, args=(), tol=1e-3): # line-search algorithm using fminbound # find the minimium of the function # func(x0+ alphadirec) global _powell_funcalls extra_args = (func, p, xi) + args alpha_min, fret, iter, num = brent(_myfunc, args=extra_args, full_output=1, tol=tol) xi = alpha_minxi _powell_funcalls += num return squeeze(fret), p+xi, xi
tc = 1.0/max(abs(vals.real)) T = arange(0,8tc,8tc / float(N))	tc = 1.0/max(abs(real(vals))) T = arange(0,10tc,10tc / float(N))	def impulse(system, X0=None, T=None, N=None): if isinstance(system, lti): sys = system else: sys = lti(system) if X0 is None: B = sys.B else: B = sys.B + X0 if N is None: N = 100 if T is None: vals = linalg.eigvals(sys.A) tc = 1.0/max(abs(vals.real)) T = arange(0,8tc,8tc / float(N)) h = zeros(T.shape, sys.A.typecode()) for k in range(len(h)): eA = Mat(linalg.expm(sys.AT[k])) B,C = map(Mat, (B,sys.C)) h[k] = squeeze(CeAB) return T, h
winfun = bohman	winfunc = bohman	def get_window(window,Nx,fftbins=1): """Return a window of length Nx and type window. If fftbins is 1, create a "periodic" window ready to use with ifftshift and be multiplied by the result of an fft (SEE ALSO fftfreq). Window types: boxcar, triang, blackman, hamming, hanning, bartlett, parzen, bohman, blackmanharris, nuttall, barthann, kaiser (needs beta), gaussian (needs std), general_gaussian (needs power, width). If the window requires no parameters, then it can be a string. If the window requires parameters, the window argument should be a tuple with the first argument the string name of the window, and the next arguments the needed parameters. If window is a floating point number, it is interpreted as the beta parameter of the kaiser window. """ sym = not fftbins try: beta = float(window) except (TypeError, ValueError): args = () if isinstance(window, types.TupleType): winstr = window[0] if len(window) > 1: args = window[1:] elif isinstance(window, types.StringType): if window in ['kaiser', 'ksr', 'gaussian', 'gauss', 'gss', 'general gaussian', 'general_gaussian', 'general gauss', 'general_gauss', 'ggs']: raise ValueError, "That window needs a parameter -- pass a tuple" else: winstr = window if winstr in ['blackman', 'black', 'blk']: winfunc = blackman elif winstr in ['triangle', 'triang', 'tri']: winfunc = triang elif winstr in ['hamming', 'hamm', 'ham']: winfunc = hamming elif winstr in ['bartlett', 'bart', 'brt']: winfunc = bartlett elif winstr in ['hanning', 'hann', 'han']: winfunc = hanning elif winstr in ['blackmanharris', 'blackharr','bkh']: winfun = blackmanharris elif winstr in ['parzen', 'parz', 'par']: winfun = parzen elif winstr in ['bohman', 'bman', 'bmn']: winfun = bohman elif winstr in ['nuttall', 'nutl', 'nut']: winfun = nuttall elif winstr in ['barthann', 'brthan', 'bth']: winfu = barthann elif winstr in ['kaiser', 'ksr']: winfunc = kaiser elif winstr in ['gaussian', 'gauss', 'gss']: winfunc = gaussian elif winstr in ['general gaussian', 'general_gaussian', 'general gauss', 'general_gauss', 'ggs']: winfunc = general_gaussian elif winstr in ['boxcar', 'box', 'ones']: winfunc = boxcar else: raise ValueError, "Unknown window type." params = (Nx,)+args + (sym,) else: winfunc = kaiser params = (Nx,beta,sym) return winfunc(*params)