def test_jac(self): # Test that Jacobian callable is handled correctly and # weighted if sigma is provided. def f(x, a, b): return a * np.exp(-b*x) def jac(x, a, b): e = np.exp(-b*x) return np.vstack((e, -a * x * e)).T xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2., 2.) # Test numerical options for least_squares backend. for method in ['trf', 'dogbox']: for scheme in ['2-point', '3-point', 'cs']: popt, pcov = curve_fit(f, xdata, ydata, jac=scheme, method=method) assert_allclose(popt, [2, 2]) # Test the analytic option. for method in ['lm', 'trf', 'dogbox']: popt, pcov = curve_fit(f, xdata, ydata, method=method, jac=jac) assert_allclose(popt, [2, 2]) # Now add an outlier and provide sigma. ydata[5] = 100 sigma = np.ones(xdata.shape[0]) sigma[5] = 200 for method in ['lm', 'trf', 'dogbox']: popt, pcov = curve_fit(f, xdata, ydata, sigma=sigma, method=method, jac=jac) # Still the optimization process is influenced somehow, # have to set rtol=1e-3. assert_allclose(popt, [2, 2], rtol=1e-3)
def test_dtypes2(self): # regression test for gh-7117: curve_fit fails if # both inputs are float32 def hyperbola(x, s_1, s_2, o_x, o_y, c): b_2 = (s_1 + s_2) / 2 b_1 = (s_2 - s_1) / 2 return o_y + b_1*(x-o_x) + b_2*np.sqrt((x-o_x)**2 + c**2/4) min_fit = np.array([-3.0, 0.0, -2.0, -10.0, 0.0]) max_fit = np.array([0.0, 3.0, 3.0, 0.0, 10.0]) guess = np.array([-2.5/3.0, 4/3.0, 1.0, -4.0, 0.5]) params = [-2, .4, -1, -5, 9.5] xdata = np.array([-32, -16, -8, 4, 4, 8, 16, 32]) ydata = hyperbola(xdata, *params) # run optimization twice, with xdata being float32 and float64 popt_64, _ = curve_fit(f=hyperbola, xdata=xdata, ydata=ydata, p0=guess, bounds=(min_fit, max_fit)) xdata = xdata.astype(np.float32) ydata = hyperbola(xdata, *params) popt_32, _ = curve_fit(f=hyperbola, xdata=xdata, ydata=ydata, p0=guess, bounds=(min_fit, max_fit)) assert_allclose(popt_32, popt_64, atol=2e-5)
def test_curvefit_simplecovariance(self): def func(x, a, b): return a * np.exp(-b*x) def jac(x, a, b): e = np.exp(-b*x) return np.vstack((e, -a * x * e)).T np.random.seed(0) xdata = np.linspace(0, 4, 50) y = func(xdata, 2.5, 1.3) ydata = y + 0.2 * np.random.normal(size=len(xdata)) sigma = np.zeros(len(xdata)) + 0.2 covar = np.diag(sigma**2) for jac1, jac2 in [(jac, jac), (None, None)]: for absolute_sigma in [False, True]: popt1, pcov1 = curve_fit(func, xdata, ydata, sigma=sigma, jac=jac1, absolute_sigma=absolute_sigma) popt2, pcov2 = curve_fit(func, xdata, ydata, sigma=covar, jac=jac2, absolute_sigma=absolute_sigma) assert_allclose(popt1, popt2, atol=1e-14) assert_allclose(pcov1, pcov2, atol=1e-14)
def test_maxfev_and_bounds(self): # gh-6340: with no bounds, curve_fit accepts parameter maxfev (via leastsq) # but with bounds, the parameter is `max_nfev` (via least_squares) x = np.arange(0, 10) y = 2*x popt1, _ = curve_fit(lambda x,p: p*x, x, y, bounds=(0, 3), maxfev=100) popt2, _ = curve_fit(lambda x,p: p*x, x, y, bounds=(0, 3), max_nfev=100) assert_allclose(popt1, 2, atol=1e-14) assert_allclose(popt2, 2, atol=1e-14)
def test_one_argument(self): def func(x,a): return x**a popt, pcov = curve_fit(func, self.x, self.y) assert_(len(popt) == 1) assert_(pcov.shape == (1,1)) assert_almost_equal(popt[0], 1.9149, decimal=4) assert_almost_equal(pcov[0,0], 0.0016, decimal=4) # Test if we get the same with full_output. Regression test for #1415. res = curve_fit(func, self.x, self.y, full_output=1) (popt2, pcov2, infodict, errmsg, ier) = res assert_array_almost_equal(popt, popt2)
def fitData(xdata, ydata): ''' Fits the provided data to the first working function (first Gompertz, then Logistic, then Richards) Returns a tuple with plateau, slope, lag, y0 and model used If no fitting was possible all values are None Please note that the plateau may be reached outside the final time point ''' retries = 2 while retries > 0: params = [None, None, None, None, None] model = '' # Initial guesses for the output parameters p0 = [getPlateau(xdata, ydata), 4.0, getFlex(xdata, ydata), 0.1, 0] if retries == 1: p0[2] = 0 try: params, pcov = curve_fit(gompertz, xdata, ydata, p0 = p0) model = 'gompertz' break except: #logger.debug('Gompertz fit failed') try: params, pcov = curve_fit(logistic, xdata, ydata, p0 = p0) model = 'logistic' break except: #logger.debug('Logistic fit failed') try: params, pcov = curve_fit(richards, xdata, ydata, p0 = p0) model = 'richards' break except: #logger.debug('Richards fit failed') retries -= 1 #logger.debug('%d retries left'%retries) # Compress again the data ydata = np.array(compress(ydata, span=2)) if len(ydata) <= 11: window_len = len(ydata) else: window_len = 11 ydata = np.array(smooth(ydata, window_len = window_len, window = 'blackman')) xdata = np.array(compress(xdata, span=2)) # params = [None, None, None, None, None] return params, model
def test_broadcast_y(self): xdata = np.arange(10) target = 4.7 * xdata ** 2 + 3.5 * xdata + np.random.rand(len(xdata)) fit_func = lambda x, a, b: a*x**2 + b*x - target for method in ['lm', 'trf', 'dogbox']: popt0, pcov0 = curve_fit(fit_func, xdata=xdata, ydata=np.zeros_like(xdata), method=method) popt1, pcov1 = curve_fit(fit_func, xdata=xdata, ydata=0, method=method) assert_array_equal(pcov0, pcov1)
def GetHist_Gauss(self): fit_gauss = lambda x, a, x0, sigma: a*exp(-np.square(x-x0)/ (2*np.square(sigma))) f1 = plt.figure(figsize=(8,12)) ax = f1.add_subplot(211); ax3 = f1.add_subplot(212) ax2 = ax.twinx(); ax4 = ax3.twinx(); ax2.set_yticklabels(("")); ax4.set_yticklabels(("")) #ax.set_ylim((0,500)) ax.set_title('trace'); ax3.set_title('retrace') ax.set_xlabel(r'$\mu_0H_{||} \ (\mathsf{T})$') ax3.set_xlabel(r'$\mu_0H_{||} \ (\mathsf{T})$') ax.set_ylabel('occurence'); ax3.set_ylabel('occurence') ax.set_xlim((-0.06,0.06)); ax3.set_xlim((-0.06,0.06)) #trace hist1 = np.histogram(self.raw[nonzero(self.raw[:,0]%(2*self.dt)<self.dt)][:,1], 200,range=[-0.06,0.06]) #retrace hist2 = np.histogram(self.raw[nonzero(self.raw[:,0]%(2*self.dt)>=self.dt)][:,1], 200,range=[-0.06,0.06]) cl = ['grey','blue','green','red'] c = [-0.04,-0.013,0.013,0.04] for i in range(4): params, cov = curve_fit(fit_gauss,hist1[1][i*50:(i+1)*50], hist1[0][i*50:(i+1)*50],[1000,c[i],0.005]) fit = fit_gauss(hist1[1][i*50:(i+1)*50],params[0],params[1],params[2]) ax2.bar(hist1[1][i*50:(i+1)*50]-3e-4,hist1[0][i*50:(i+1)*50], width=6e-4,color=cl[i],edgecolor='None') ax2.plot(hist1[1][i*50:(i+1)*50],fit,'k--') ax.bar(params[1],np.sqrt(2*pi)*params[0]*params[2],align='center', alpha=0.3,width=6*params[2],color='grey',edgecolor='black', linewidth=2) for i in range(4): params, cov = curve_fit(fit_gauss,hist2[1][i*50:(i+1)*50], hist2[0][i*50:(i+1)*50],[1000,c[i],0.005]) fit = fit_gauss(hist2[1][i*50:(i+1)*50],params[0],params[1],params[2]) ax4.bar(hist2[1][i*50:(i+1)*50]-3e-4,hist2[0][i*50:(i+1)*50], width=6e-4,color=cl[i],edgecolor='None') ax4.plot(hist2[1][i*50:(i+1)*50],fit,'k--') ax3.bar(params[1],np.sqrt(2*pi)*params[0]*params[2],align='center', alpha=0.3,width=6*params[2],color='grey',edgecolor='black', linewidth=2) f1.tight_layout() f1.savefig('Fidelity.png',dpi=300,format='png') f1.savefig('Fidelity.pdf',dpi=300,format='pdf')
def test_bounds_p0(self): # This test is for issue #5719. The problem was that an initial guess # was ignored when 'trf' or 'dogbox' methods were invoked. def f(x, a): return np.sin(x + a) xdata = np.linspace(-2 * np.pi, 2 * np.pi, 40) ydata = np.sin(xdata) bounds = (-3 * np.pi, 3 * np.pi) for method in ["trf", "dogbox"]: popt_1, _ = curve_fit(f, xdata, ydata, p0=2.1 * np.pi) popt_2, _ = curve_fit(f, xdata, ydata, p0=2.1 * np.pi, bounds=bounds, method=method) # If the initial guess is ignored, then popt_2 would be close 0. assert_allclose(popt_1, popt_2)
def test_regression_2639(self): # This test fails if epsfcn in leastsq is too large. x = [ 574.14200000000005, 574.154, 574.16499999999996, 574.17700000000002, 574.18799999999999, 574.19899999999996, 574.21100000000001, 574.22199999999998, 574.23400000000004, 574.245, ] y = [859.0, 997.0, 1699.0, 2604.0, 2013.0, 1964.0, 2435.0, 1550.0, 949.0, 841.0] guess = [574.1861428571428, 574.2155714285715, 1302.0, 1302.0, 0.0035019999999983615, 859.0] good = [5.74177150e02, 5.74209188e02, 1.74187044e03, 1.58646166e03, 1.0068462e-02, 8.57450661e02] def f_double_gauss(x, x0, x1, A0, A1, sigma, c): return ( A0 * np.exp(-(x - x0) ** 2 / (2.0 * sigma ** 2)) + A1 * np.exp(-(x - x1) ** 2 / (2.0 * sigma ** 2)) + c ) popt, pcov = curve_fit(f_double_gauss, x, y, guess, maxfev=10000) assert_allclose(popt, good, rtol=1e-5)
def stdDev(self): ''' get the standard deviation from the PSF is evaluated as 2d Gaussian ''' if self._corrPsf is None: self.psf() p = self._corrPsf.copy() mn = p.min() p[p<0.05*p.max()] = mn p-=mn p/=p.sum() x,y = self._psfGridCoords() x = x.flatten() y = y.flatten() guess = (1,1,0) param, _ = curve_fit(self._fn, (x,y), p.flatten(), guess) self._fitParam = param stdx,stdy = param[:2] self._std = (stdx+stdy)/2 return self._std
def fit_curve(r, n, c): '''Fit the data c(r) where c=concordance and r=call rate using an exponential approximation f. The fit is weighted using a normal approximation to a sum of binomial distributions, each representing a single events of a SNP being concordant for a single pair of samples at a single IBD2 segment.''' # print r, c (p, _) = curve_fit(model, r, c) # , sigma=np.maximum(1e-5, np.sqrt(c * (1 - c) / n))) return model(r, *p), p
def T1fit_run(x,y,guess,abs_fit): import numpy as np from scipy.optimize.minpack import curve_fit #t_order= x.argsort() #x=x[t_order] #y=y[t_order] smoothx = np.linspace(x[0], x[-1], 1000) #guess_a, guess_b, guess_c = y.max(), 2 * y.max(), T1_guess #guess = [guess_a, guess_b, guess_c] if abs_fit: exp_f = lambda x, A, B, t:abs((A - (B * np.exp(-x / t)))) else: exp_f = lambda x, A, B, t:((A - (B * np.exp(-x / t)))) params, cov = curve_fit(exp_f, x, y, p0=guess) A, B, t = params #best_fit = lambda x: abs((A - (B * np.exp(-x / t)))) smoothy = exp_f(smoothx, A, B, t) T1 = t * (B / A - 1) yfitting = exp_f(x, A, B, t) #yfitting = abs(A - (B * np.exp(-x / t))) residue=np.sum(abs(yfitting - y)); result_dict = { 'A': A, 'B': B, 'T1_star':t, 'T1':T1, 't_val_org':x, 'y_val_org':y, 't_val_fit':smoothx, 'y_val_fit':smoothy, 'residue':residue, 'error_status':0, 'error_str':'OK!', } return result_dict
def fit_ha_and_n2(x, y, dy): ha = 6562.81 n2 = 6583.41 mask = np.logical_not(np.logical_or(np.isnan(y), np.isnan(x))) args = np.argsort(x[mask]) x = x[mask][args] y = y[mask][args] if not dy is None: dy = dy[mask][args] guess = np.zeros(8) guess[0] = np.percentile(y, 10) guess[3] = x[y == np.max(y)][0] guess_beta = ((guess[3] / ha) ** 2 - 1) / ((guess[3] / ha) ** 2 + 1) guess_n2 = n2 * (1 + guess_beta) / np.sqrt(1 - guess_beta ** 2) haslice = np.logical_and(x > guess[3] - 10, x < guess[3] + 10) n2slice = np.logical_and(x > guess_n2 - 10, x < guess_n2 + 10) guess[1] = np.sum(0.5 * (y[haslice][1:] + y[haslice][:-1] - 2 * guess[0]) * np.diff(x[haslice])) guess[2] = np.sum(0.5 * (y[n2slice][1:] + y[n2slice][:-1] - 2 * guess[0]) * np.diff(x[n2slice])) guess[4:8] = 2 try: fit = curve_fit(ha_and_n2_voigts, x, y, p0=guess, sigma=dy)[0] success = True except: fit = guess success = False return fit, success
def Lifet(self,dt_max,t_max,save = False): delta_t = self.delta_t temp1 = [] temp2 = [] tau = 0 for ii in range(size(self.data[:,0])-1): if (self.data[ii,1] == self.data[ii+1,1]): if(self.data[ii+1,0]-self.data[ii,0]<dt_max): tau += self.data[ii+1,0]-self.data[ii,0] else: if (self.data[ii,1] == +0.5): temp1.append(tau) if (self.data[ii,1] == -0.5): temp2.append(tau) tau = 0 else: if (self.data[ii,1] == +0.5): temp1.append(tau) if (self.data[ii,1] == -0.5): temp2.append(tau) tau = 0 temp = [temp1,temp2] exp_fit = lambda t,tau,a : a*exp(-t/tau) time = np.linspace(0,120,100) f1 = plt.figure() #for i in range(2): ax = f1.add_subplot(111) ax.set_yscale('log') ax.set_ylim(0.005,1) ax.set_yticks((0.01,0.1,1)) ax.set_xlabel(r'$t \ (\mathsf{s})$') ax.set_ylabel(r"$\langle m_{\mathsf{I}} \ = \ -1/2 \rangle $"); ax.set_xlim((0,t_max)); ax.set_xticks((0,20,40,60,80,100,120)) #create Histogramm of lifetime distribution H1 = np.histogram(np.array(temp[0]), bins=np.linspace(delta_t,120,int(120/delta_t))) #extract all nonzero elements # lft = (np.reshape(np.concatenate((H1[1][nonzero(H1[0]!=0)], H1[0][nonzero(H1[0]!=0)])), (size(H1[1][nonzero(H1[0]!=0)]),2),order='F')) params, cov = curve_fit(exp_fit,lft[:,0],lft[:,1],[10,100]) fit = exp(-time/params[0]) #normalize lft[:,1] = lft[:,1]/params[1] ax.scatter(lft[:,0],lft[:,1],c='k') ax.plot(time,fit,'r--',linewidth=3) ax.text(0.6,0.8,r'$\tau$'+' = '+str(round(params[0]*100)/100)+'s', fontsize = 'x-large', transform = ax.transAxes) f1.tight_layout() if save == True: f1.savefig('lifetime.png',dpi=300,format='png') f1.savefig('lifetime.pdf',dpi=300,format='pdf')
def test_curvefit_covariance(self): def funcp(x, a, b): rotn = np.array( [[1.0 / np.sqrt(2), -1.0 / np.sqrt(2), 0], [1.0 / np.sqrt(2), 1.0 / np.sqrt(2), 0], [0, 0, 1.0]] ) return rotn.dot(a * np.exp(-b * x)) def jacp(x, a, b): rotn = np.array( [[1.0 / np.sqrt(2), -1.0 / np.sqrt(2), 0], [1.0 / np.sqrt(2), 1.0 / np.sqrt(2), 0], [0, 0, 1.0]] ) e = np.exp(-b * x) return rotn.dot(np.vstack((e, -a * x * e)).T) def func(x, a, b): return a * np.exp(-b * x) def jac(x, a, b): e = np.exp(-b * x) return np.vstack((e, -a * x * e)).T np.random.seed(0) xdata = np.arange(1, 4) y = func(xdata, 2.5, 1.0) ydata = y + 0.2 * np.random.normal(size=len(xdata)) sigma = np.zeros(len(xdata)) + 0.2 covar = np.diag(sigma ** 2) # Get a rotation matrix, and obtain ydatap = R ydata # Chisq = ydata^T C^{-1} ydata # = ydata^T R^T R C^{-1} R^T R ydata # = ydatap^T Cp^{-1} ydatap # Cp^{-1} = R C^{-1} R^T # Cp = R C R^T, since R^-1 = R^T rotn = np.array( [[1.0 / np.sqrt(2), -1.0 / np.sqrt(2), 0], [1.0 / np.sqrt(2), 1.0 / np.sqrt(2), 0], [0, 0, 1.0]] ) ydatap = rotn.dot(ydata) covarp = rotn.dot(covar).dot(rotn.T) for jac1, jac2 in [(jac, jacp), (None, None)]: for absolute_sigma in [False, True]: popt1, pcov1 = curve_fit(func, xdata, ydata, sigma=sigma, jac=jac1, absolute_sigma=absolute_sigma) popt2, pcov2 = curve_fit(funcp, xdata, ydatap, sigma=covarp, jac=jac2, absolute_sigma=absolute_sigma) assert_allclose(popt1, popt2, atol=1e-14) assert_allclose(pcov1, pcov2, atol=1e-14)
def test_array_like(self): # Test sequence input. Regression test for gh-3037. def f_linear(x, a, b): return a*x + b x = [1, 2, 3, 4] y = [3, 5, 7, 9] assert_allclose(curve_fit(f_linear, x, y)[0], [2, 1], atol=1e-10)
def test_one_argument(self): def func(x,a): return x**a popt, pcov = curve_fit(func, self.x, self.y) assert_(len(popt) == 1) assert_(pcov.shape == (1,1)) assert_almost_equal(popt[0], 1.9149, decimal=4) assert_almost_equal(pcov[0,0], 0.0016, decimal=4)
def test_two_argument(self): def func(x, a, b): return b*x**a popt, pcov = curve_fit(func, self.x, self.y) assert_(len(popt) == 2) assert_(pcov.shape == (2,2)) assert_array_almost_equal(popt, [1.7989, 1.1642], decimal=4) assert_array_almost_equal(pcov, [[0.0852, -0.1260],[-0.1260, 0.1912]], decimal=4)
def fitGaussian(x, y, guessMu, guessSigma): """ Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for mu and sigma, returns fits for mu and sigma """ g_guess = [guessMu, guessSigma] gf = lambda fx, mu, sigma: gaussian(fx, mu, sigma) params, cov = curve_fit(gf, x, y, p0=g_guess, maxfev=2000) return params[0], params[1] #params = [mu, sigma]
def fitPoisson(x,y,guessLambda): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for expectation value, returns fit values for lambda. ''' p_guess = [guessLambda] pf = lambda fx, lam: poisson(fx, lam) params, cov = curve_fit(pf, x, y, p0=p_guess, maxfev=2000) return params[0] #params = [lambda]
def fitGaussian(x,y,guessMu,guessSigma): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for mu and sigma, returns fits for mu and sigma ''' g_guess = [guessMu,guessSigma] gf = lambda fx, mu, sigma: gaussian(fx, mu, sigma) params, cov = curve_fit(gf, x, y, p0=g_guess, maxfev=2000) return params[0], params[1] #params = [mu, sigma]
def test_two_argument(self): def func(x, a, b): return b*x**a popt, pcov = curve_fit(func, self.x, self.y) assert_(len(popt) == 2) assert_(pcov.shape == (2,2)) assert_array_almost_equal(popt, [1.7989, 1.1642], decimal=4) assert_array_almost_equal(pcov, [[0.0852, -0.1260], [-0.1260, 0.1912]], decimal=4)
def fitMR(x, y, guessIc, guessIs): """ Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for Ic and Is, returns fit values for Ic and Is. """ mr_guess = [guessIc, guessIs] mrf = lambda fx, Ic, Is: modifiedRician(fx, Ic, Is) params, cov = curve_fit(mrf, x, y, p0=mr_guess, maxfev=2000) return params[0], params[1] #params = [fitIc, fitIs]
def fitExponential(x, y, guessLam, guessTau, guessf0): """ Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for mu and sigma, returns fits for mu and sigma """ e_guess = [guessLam, guessTau, guessf0] ef = lambda fx, lam, tau, f0: exponential(fx, lam, tau, f0) params, cov = curve_fit(ef, x, y, p0=e_guess, maxfev=2000) return params[0], params[1], params[2] #params = [lambda, tau, f0]
def fitExponential(x,y,guessLam,guessTau,guessf0): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for mu and sigma, returns fits for mu and sigma ''' e_guess = [guessLam,guessTau,guessf0] ef = lambda fx, lam, tau, f0: exponential(fx, lam,tau,f0) params, cov = curve_fit(ef, x, y, p0=e_guess, maxfev=2000) return params[0], params[1], params[2] #params = [lambda, tau, f0]
def fitPoisson(x, y, guessLambda): """ Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for expectation value, returns fit values for lambda. """ p_guess = [guessLambda] pf = lambda fx, lam: poisson(fx, lam) params, cov = curve_fit(pf, x, y, p0=p_guess, maxfev=2000) return params[0] #params = [lambda]
def fitMR(x, y, guessIc, guessIs): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for Ic and Is, returns fit values for Ic and Is. ''' mr_guess = [guessIc,guessIs] mrf = lambda fx, Ic, Is: modifiedRician(fx, Ic, Is) params, cov = curve_fit(mrf, x, y, p0=mr_guess, maxfev=2000) return params[0], params[1] #params = [fitIc, fitIs]
def test_maxfev_and_bounds(self): # gh-6340: with no bounds, curve_fit accepts parameter maxfev (via leastsq) # but with bounds, the parameter is `max_nfev` (via least_squares) x = np.arange(0, 10) y = 2 * x popt1, _ = curve_fit(lambda x, p: p * x, x, y, bounds=(0, 3), maxfev=100) popt2, _ = curve_fit(lambda x, p: p * x, x, y, bounds=(0, 3), max_nfev=100) assert_allclose(popt1, 2, atol=1e-14) assert_allclose(popt2, 2, atol=1e-14)
def pvsatMat(Geff,Tmod,power,area, **kwargs): ''' Origin: H2M Coefficients: four Result: the four coefficients Parameters ------------ Geff: 1d array or list indoor irradiance measurements (Watt/m2) Tmod: 1d array or list indoor module temperature measurements. power: 1d array or list power (Watt) Area: numpy float the area of the module Returns: a dictionary with the four coefficients of the model -------- Note: Coefficient symbols are consistent to the source ''' Geff = np.array((Geff),dtype = float) Tmod = np.array((Tmod),dtype = float) x = np.array((Geff,Tmod),dtype = float) power = np.array(power) # quality control Geff[Geff<0.0] = 0.0001 power[power<0.0] = 0.0 def _pvs(x,a,a1,a2,a3): p = (a1 + a2*x[0] +a3*np.log(x[0])) * (1+a*(x[1]-25))* area * x[0] return p params, pcov = curve_fit(_pvs,x,power) # currently works with Lavenberg- Marquardt optimisation algorithm ermodule = {"a":params[0], "a1":params[1], "a2":params[2], "a3":params[3]} print(ermodule) return ermodule
def Lifet(self): temp1 = [] temp2 = [] temp3 = [] temp4 = [] tau = 0 for ii in range(size(self.data[:,0])-1): if (self.data[ii,1] == self.data[ii+1,1]): tau += self.data[ii+1,0]-self.data[ii,0] else: if (self.data[ii,1] == -1.5): temp1.append(tau) if (self.data[ii,1] == -0.5): temp2.append(tau) if (self.data[ii,1] == 0.5): temp3.append(tau) if (self.data[ii,1] == 1.5): temp4.append(tau) tau = 0 temp = [temp1,temp2,temp3,temp4] exp_fit = lambda t,tau,a : a*exp(-t/tau) time = np.linspace(0,120,100) f1 = plt.figure(figsize=(12,8)) for i in range(4): ax = f1.add_subplot(2,2,i+1) ax.set_xlabel(r'$t \ (s)$') ax.set_ylabel(r'$<m_{\mathsf{I}} \ = \ $'+str(+1.5-i)+r"$>$"); ax.set_xlim((0,120)); ax.set_xticks((0,30,60,90,120)) ax.set_yticks((0,0.5,1)) ax.set_ylim((-0.1,1.1)); #create Histogramm of lifetime distribution H1 = np.histogram(np.array(temp[i]),bins=np.linspace(1,48,120)) #extract all nonzero elements # lft = (np.reshape(np.concatenate((H1[1][nonzero(H1[0]!=0)], H1[0][nonzero(H1[0]!=0)])), (size(H1[1][nonzero(H1[0]!=0)]),2),order='F')) params, cov = curve_fit(exp_fit,lft[:,0],lft[:,1],[10,100]) fit = exp(-time/params[0]) #normalize lft[:,1] = lft[:,1]/params[1] ax.scatter(lft[:,0],lft[:,1],c='k') ax.plot(time,fit,'r--',linewidth=3) ax.text(0.3,0.8,r'$\tau$'+' = '+str(round(params[0]*100)/100)+'s', fontsize = 'x-large', transform = ax.transAxes) f1.tight_layout() f1.savefig('lifetime.png',dpi=300,format='png') f1.savefig('lifetime.pdf',dpi=300,format='pdf')
def _parabola_fitter(x_data, y_data): tau = x_data[y_data.argmax()] c = np.mean(y_data) a = (y_data[2] - y_data[0]) / (x_data[2] - x_data[0]) / 2. / ( x_data[1] - tau * .99) p0 = (a, tau, c) popt, pcov = curve_fit(parabola, x_data, y_data, p0) return popt
def test_curvefit_covariance(self): def funcp(x, a, b): rotn = np.array([[1./np.sqrt(2), -1./np.sqrt(2), 0], [1./np.sqrt(2), 1./np.sqrt(2), 0], [0, 0, 1.0]]) return rotn.dot(a * np.exp(-b*x)) def jacp(x, a, b): rotn = np.array([[1./np.sqrt(2), -1./np.sqrt(2), 0], [1./np.sqrt(2), 1./np.sqrt(2), 0], [0, 0, 1.0]]) e = np.exp(-b*x) return rotn.dot(np.vstack((e, -a * x * e)).T) def func(x, a, b): return a * np.exp(-b*x) def jac(x, a, b): e = np.exp(-b*x) return np.vstack((e, -a * x * e)).T np.random.seed(0) xdata = np.arange(1, 4) y = func(xdata, 2.5, 1.0) ydata = y + 0.2 * np.random.normal(size=len(xdata)) sigma = np.zeros(len(xdata)) + 0.2 covar = np.diag(sigma**2) # Get a rotation matrix, and obtain ydatap = R ydata # Chisq = ydata^T C^{-1} ydata # = ydata^T R^T R C^{-1} R^T R ydata # = ydatap^T Cp^{-1} ydatap # Cp^{-1} = R C^{-1} R^T # Cp = R C R^T, since R^-1 = R^T rotn = np.array([[1./np.sqrt(2), -1./np.sqrt(2), 0], [1./np.sqrt(2), 1./np.sqrt(2), 0], [0, 0, 1.0]]) ydatap = rotn.dot(ydata) covarp = rotn.dot(covar).dot(rotn.T) for jac1, jac2 in [(jac, jacp), (None, None)]: for absolute_sigma in [False, True]: popt1, pcov1 = curve_fit(func, xdata, ydata, sigma=sigma, jac=jac1, absolute_sigma=absolute_sigma) popt2, pcov2 = curve_fit(funcp, xdata, ydatap, sigma=covarp, jac=jac2, absolute_sigma=absolute_sigma) assert_allclose(popt1, popt2, rtol=1.2e-7, atol=1e-14) assert_allclose(pcov1, pcov2, rtol=1.2e-7, atol=1e-14)
def test_ignore_nan(self): # Test for handling of NaNs in input data when ignore_nan flag is set: gh-11841 f = lambda x, a, b: a*x + b xdata = np.array([1, 2, 3]) ydata = np.array([3, 4, 6]) expected = curve_fit(f, xdata, ydata) xdata = np.array([1, 2, np.nan, 3, 4 ,np.nan]) ydata = np.array([3, 4, 5, 6, np.nan, 7]) result = curve_fit(f, xdata, ydata, ignore_nan=True) assert result == expected xdata = np.array([np.nan, np.nan, np.nan]) ydata = np.array([np.nan, np.nan, np.nan]) result = curve_fit(f, xdata, ydata, ignore_nan=True) assert result == np.nan
def fit_delta_p(self): """ Fit the PO2 difference between RBC and plasma using a fitting function that depends on linear density and the oxygen flux out of the capillary (j_t). Returns: fitted coefficient """ x, delta_p = self._assemble_fit_func_xy() return curve_fit(self.fit_func, x, delta_p)
def test_one_argument(self): def func(x, a): return x**a popt, pcov = curve_fit(func, self.x, self.y) assert_(len(popt) == 1) assert_(pcov.shape == (1, 1)) assert_almost_equal(popt[0], 1.9149, decimal=4) assert_almost_equal(pcov[0, 0], 0.0016, decimal=4) # Test if we get the same with full_output. Regression test for #1415. # Also test if check_finite can be turned off. res = curve_fit(func, self.x, self.y, full_output=1, check_finite=False) (popt2, pcov2, infodict, errmsg, ier) = res assert_array_almost_equal(popt, popt2)
def fit(function, x, y): """Fit the provided functrion to the x and y values. The function parameters and the parameters covariance.""" # Compute guesses for the parameters # This is necessary to get significant fits p0 = [guess_plateau(x, y), 4.0, guess_lag(x, y), 0.1, min(y)] params, pcov = curve_fit(function, x, y, p0=p0) return params, pcov
def run(self, x, y, dy): if leastsq is None: return self.result(x, y, dy, None, None, msg='scipy leastsq function not available') if len(x) < 2: return self.result(x, y, dy, None, None, msg='need at least two data points to fit') xn, yn, dyn = self._prepare(x, y, dy) if len(xn) < len(self.parnames): return self.result(xn, yn, dyn, None, None, msg='need at least as many valid data points ' 'as there are parameters') if not len(self.parstart): # pylint: disable=len-as-condition try: self.parstart = self.guesspar(xn, yn) except Exception as e: return self.result(xn, yn, dyn, None, None, msg='while guessing parameters: %s' % e) try: # pylint: disable=unbalanced-tuple-unpacking popt, pcov = curve_fit( self.model, xn, yn, self.parstart, dyn, # default of 1000 can be too restrictive, # especially with automatic initial guess maxfev=5000) if isinf(pcov).all(): parerrors = full_like(popt, 0) else: parerrors = sqrt(abs(diagonal(pcov))) except (RuntimeError, ValueError, TypeError) as e: return self.result(xn, yn, dyn, None, None, msg=str(e)) return self.result(xn, yn, dyn, popt, parerrors)
def fit(x): plimit = np.clip(x[0], 0, 100) gradlim = np.nanpercentile(np.abs(pder), plimit) idx = pder != 0 idx &= np.abs(resid) < 5 * unc idx &= np.abs(pder) < gradlim # Sort pixels according to the change of the i # parameter needed to match the observations idx_sort = np.argsort(resid[idx] / pder[idx]) ch_x = resid[idx][idx_sort] / pder[idx][idx_sort] # Weights of the individual pixels also sorted ch_y = np.abs(pder[idx][idx_sort]) / unc[idx][idx_sort] # Cumulative weights ch_y = np.cumsum(ch_y) # Normalized cumulative weights ch_y /= ch_y[-1] # Initial guess hmed = np.interp(0.5, ch_y, ch_x) interval = np.interp([0.16, 0.84], ch_y, ch_x) sigma_estimate = (interval[1] - interval[0]) / 2 p0 = [hmed, sigma_estimate, 1] sopt = p0 # Fit the distribution try: sopt, _ = curve_fit(cdf, ch_x, ch_y, p0=p0) except RuntimeError: # Fit failed, use dogbox instead try: sopt, _ = curve_fit(cdf, ch_x, ch_y, p0=p0, method="dogbox") except RuntimeError: sopt = p0 sigma, interval = std(*sopt) hmed = (interval[0] + interval[1]) / 2 res = ch_y - cdf(ch_x, *sopt) return np.sum(np.nan_to_num(res)**2) / ch_y.size
def test_jac(self): # Test that Jacobian callable is handled correctly and # weighted if sigma is provided. def f(x, a, b): return a * np.exp(-b * x) def jac(x, a, b): e = np.exp(-b * x) return np.vstack((e, -a * x * e)).T xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2., 2.) # Test numerical options for least_squares backend. for method in ['trf', 'dogbox']: for scheme in ['2-point', '3-point', 'cs']: popt, pcov = curve_fit(f, xdata, ydata, jac=scheme, method=method) assert_allclose(popt, [2, 2]) # Test the analytic option. for method in ['lm', 'trf', 'dogbox']: popt, pcov = curve_fit(f, xdata, ydata, method=method, jac=jac) assert_allclose(popt, [2, 2]) # Now add an outlier and provide sigma. ydata[5] = 100 sigma = np.ones(xdata.shape[0]) sigma[5] = 200 for method in ['lm', 'trf', 'dogbox']: popt, pcov = curve_fit(f, xdata, ydata, sigma=sigma, method=method, jac=jac) # Still the optimization process is influenced somehow, # have to set rtol=1e-3. assert_allclose(popt, [2, 2], rtol=1e-3)
def test_bounds_p0(self): # This test is for issue #5719. The problem was that an initial guess # was ignored when 'trf' or 'dogbox' methods were invoked. def f(x, a): return np.sin(x + a) xdata = np.linspace(-2 * np.pi, 2 * np.pi, 40) ydata = np.sin(xdata) bounds = (-3 * np.pi, 3 * np.pi) for method in ['trf', 'dogbox']: popt_1, _ = curve_fit(f, xdata, ydata, p0=2.1 * np.pi) popt_2, _ = curve_fit(f, xdata, ydata, p0=2.1 * np.pi, bounds=bounds, method=method) # If the initial guess is ignored, then popt_2 would be close 0. assert_allclose(popt_1, popt_2)
def fitBlackbody(wvls, flux, fraction=1.0, newWvls=None, tempGuess=8600): """ Seth 11/13/14 Simple blackbody fitting function that returns BB temperature and fluxes if requested. INPUTS: wvls - wavelengths of data points (in Angstroms!) flux - fluxes of data points (in ergs/s/cm^2/Angstrom!) fraction - what fraction of spectrum's red end to use for fit. Default is 1.0 (use whole spectrum). for example, fraction=1.0/5.0 only fits BB to last 20% of spectrum. newWvls - 1D array of wavelengths in angstroms. If given, function returns blackbody fit at requested points tempGuess - manually adjust guess of BB temperature (in Kelvin) that fit starts with OUTPUTS: T - temperature in Kelvin of blackbody fit newFlux - fluxes calculated at newWvls using the BB equation generated by the fit """ c = 3.00E10 # cm/s h = 6.626E-27 # erg*s k = 1.3806488E-16 # erg/K x = wvls norm = flux.max() y = flux / norm # print("BBfit using last ", fraction * 100, "% of spectrum only") fitx = x[int((1.0 - fraction) * len(x))::] fity = y[int((1.0 - fraction) * len(x))::] guess_a, guess_b = 1 / (2 * h * c ** 2 / 1e-9), tempGuess # Constant, Temp guess = [guess_a, guess_b] blackbody = lambda fx, N, T: N * 2 * h * c ** 2 / (fx) ** 5 * ( np.exp(h * c / (k * T * (fx))) - 1) ** -1 # Planck Law # blackbody = lambda fx, N, T: N*2*c*k*T/(fx)**4 #Rayleigh Jeans tail # blackbody = lambda fx, N, T: N*2*h*c**2/(fx**5) * exp(-h*c/(k*T*fx)) #Wein Approx params, cov = curve_fit(blackbody, fitx * 1.0e-8, fity, p0=guess, maxfev=2000) N, T = params print("BBFit:\nN = %s\nT = %s\n" % (N, T)) if newWvls is not None: best_fit = lambda fx: N * 2 * h * c ** 2 / (fx) ** 5 * ( np.exp(h * c / (k * T * (fx))) - 1) ** -1 # Planck Law # best_fit = lambda fx: N*2*c*k*T/(fx)**4 # Rayleigh Jeans Tail # best_fit = lambda fx: N*2*h*c**2/(fx**5) * exp(-h*c/(k*T*fx)) #Wein Approx calcx = np.array(newWvls, dtype=float) newFlux = best_fit(calcx * 1.0E-8) newFlux *= norm return T, newFlux else: return T
def fitExponentialToStdHb(self): """ Fit parameters of an exponential curve to the simulated standard deviation Return: float, fitted decay length """ stdSim = self.rbcDataPostProcessor.fieldStd('Hb_mean', self.sValues(), nAverage=self.nAverage) popt, pcov = curve_fit(self.exponentialFitFunc, self.xValues, stdSim, p0=(100e-6, stdSim[0])) return popt
def test_bounds(self): def f(x, a, b): return a * np.exp(-b * x) xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2.0, 2.0) # The minimum w/out bounds is at [2., 2.], # and with bounds it's at [1.5, smth]. bounds = ([1.0, 0], [1.5, 3.0]) for method in [None, "trf", "dogbox"]: popt, pcov = curve_fit(f, xdata, ydata, bounds=bounds, method=method) assert_allclose(popt[0], 1.5) # With bounds, the starting estimate is feasible. popt, pcov = curve_fit(f, xdata, ydata, method="trf", bounds=([0.0, 0], [0.6, np.inf])) assert_allclose(popt[0], 0.6) # method='lm' doesn't support bounds. assert_raises(ValueError, curve_fit, f, xdata, ydata, bounds=bounds, method="lm")
def mat61853_1(Geff,Tmod,power, **kwargs): ''' Parameters ------------ Geff: numpy float or list indoor irradiance measurements (Watt/m2) Tmod: numpy float or list module temperature indoor measurements. power: numpy float or 1d array power returned for the given irradiance, module temperature (Watt) Returns: -------- ermodule: dict A dictionary containing the coefficients of the module It should contain the six fields required for this model ''' Tmod = np.array(Tmod, dtype = float) Geff = np.array((Geff),dtype = float) power = np.array((power), dtype = float) Geff[Geff<0.0] = 0.0001 power[power<0.0] = 0.0 x = np.array((Geff, Tmod), dtype = float) def _matiec(x,a0,a1,a2,a3,a4): #power = (a0 + a1*Geff + a2*(Geff**2))*(a4 + a5*Tmod) p = (a0 + a1*x[0] + a2*(x[0]**2))*(a3 + a4*x[1]) return p params, pcov = curve_fit(_matiec,x,power) ermodule = {"a0":params[0], "a1":params[1], "a2":params[2], "a3":params[3], "a4":params[4]} print(ermodule) return ermodule
def fitLorentzian(x,y,guessGam,guessX0): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for Gamma and x0, returns fit values for Gamma and x0. ''' lor_guess = [guessGam,guessX0] lf = lambda fx, gam, x0: lorentzian(fx, gam, x0) params, cov = curve_fit(lf, x, y, p0=lor_guess, maxfev=2000) return params[0], params[1] #params = [gamma, x0] #def fitLorentzian(x,y,guessGam): '''
def test_method_argument(self): def f(x, a, b): return a * np.exp(-b * x) xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2.0, 2.0) for method in ["trf", "dogbox", "lm", None]: popt, pcov = curve_fit(f, xdata, ydata, method=method) assert_allclose(popt, [2.0, 2.0]) assert_raises(ValueError, curve_fit, f, xdata, ydata, method="unknown")
def test_method_argument(self): def f(x, a, b): return a * np.exp(-b*x) xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2., 2.) for method in ['trf', 'dogbox', 'lm', None]: popt, pcov = curve_fit(f, xdata, ydata, method=method) assert_allclose(popt, [2., 2.]) assert_raises(ValueError, curve_fit, f, xdata, ydata, method='unknown')
def fitLorentzian(x, y, guessGam, guessX0): ''' Given a histogram of intensity values (x = I bin centers, y = N(I)) and a guess for Gamma and x0, returns fit values for Gamma and x0. ''' lor_guess = [guessGam, guessX0] lf = lambda fx, gam, x0: lorentzian(fx, gam, x0) params, cov = curve_fit(lf, x, y, p0=lor_guess, maxfev=2000) return params[0], params[1] #params = [gamma, x0] #def fitLorentzian(x,y,guessGam): '''
def fit2dArrayToFn(arr, fn, mask=None, down_scale_factor=None, output_shape=None, guess=None, outgrid=None): """Fit a 2d array to a 2d function USE ONLY MASKED VALUES * [down_scale_factor] map to speed up fitting procedure, set value smaller than 1 * [output_shape] shape of the output array * [guess] must be scaled using [scale_factor] Returns: Fitted map, fitting params (scaled), error """ if mask is None: #assert outgrid is not None mask = np.ones(shape=arr.shape, dtype=bool) if down_scale_factor is None: if mask.sum() > 1000: down_scale_factor = 0.3 else: down_scale_factor = 1 if down_scale_factor != 1: # SCALE TO DECREASE AMOUNT OF POINTS TO FIT: arr2 = zoom(arr, down_scale_factor) mask = zoom(mask, down_scale_factor, output=bool) else: arr2 = arr # USE ONLY VALID POINTS: x, y = np.where(mask) z = arr2[mask] # FIT: print (guess,111) parameters, cov_matrix = curve_fit(fn, (x, y), z, p0=guess) # ERROR: perr = np.sqrt(np.diag(cov_matrix)) if outgrid is not None: yy,xx = outgrid rebuilt = fn((yy,xx), *parameters) else: if output_shape is None: output_shape = arr.shape fx = arr2.shape[0] / output_shape[0] fy = arr2.shape[1] / output_shape[1] rebuilt = np.fromfunction(lambda x, y: fn((x * fx, y * fy), *parameters), output_shape) return rebuilt, parameters, perr
def fitExponentialToHbDifference(self): """ Fit parameters of an exponential curve to the simulated hemoglobin saturation difference Return: float, fitted decay length """ diffSim = self.hbDifferenceFromSimul(self.xValues) popt, pcov = curve_fit(self.exponentialFitFunc, self.xValues, diffSim, p0=(100e-6, diffSim[0])) return popt
def test_func_is_classmethod(self): class test_self(object): """This class tests if curve_fit passes the correct number of arguments when the model function is a class instance method. """ def func(self, x, a, b): return b * x**a test_self_inst = test_self() popt, pcov = curve_fit(test_self_inst.func, self.x, self.y) assert_(pcov.shape == (2, 2)) assert_array_almost_equal(popt, [1.7989, 1.1642], decimal=4) assert_array_almost_equal(pcov, [[0.0852, -0.1260], [-0.1260, 0.1912]], decimal=4)
def test_bounds(self): def f(x, a, b): return a * np.exp(-b*x) xdata = np.linspace(0, 1, 11) ydata = f(xdata, 2., 2.) # The minimum w/out bounds is at [2., 2.], # and with bounds it's at [1.5, smth]. bounds = ([1., 0], [1.5, 3.]) for method in [None, 'trf', 'dogbox']: popt, pcov = curve_fit(f, xdata, ydata, bounds=bounds, method=method) assert_allclose(popt[0], 1.5) # With bounds, the starting estimate is feasible. popt, pcov = curve_fit(f, xdata, ydata, method='trf', bounds=([0., 0], [0.6, np.inf])) assert_allclose(popt[0], 0.6) # method='lm' doesn't support bounds. assert_raises(ValueError, curve_fit, f, xdata, ydata, bounds=bounds, method='lm')
def test_pcov(self): xdata = np.array([0, 1, 2, 3, 4, 5]) ydata = np.array([1, 1, 5, 7, 8, 12]) sigma = np.array([1, 2, 1, 2, 1, 2]) def f(x, a, b): return a * x + b popt, pcov = curve_fit(f, xdata, ydata, p0=[2, 0], sigma=sigma) perr_scaled = np.sqrt(np.diag(pcov)) assert_allclose(perr_scaled, [0.20659803, 0.57204404], rtol=1e-3) popt, pcov = curve_fit(f, xdata, ydata, p0=[2, 0], sigma=3 * sigma) perr_scaled = np.sqrt(np.diag(pcov)) assert_allclose(perr_scaled, [0.20659803, 0.57204404], rtol=1e-3) popt, pcov = curve_fit(f, xdata, ydata, p0=[2, 0], sigma=sigma, absolute_sigma=True) perr = np.sqrt(np.diag(pcov)) assert_allclose(perr, [0.30714756, 0.85045308], rtol=1e-3) popt, pcov = curve_fit(f, xdata, ydata, p0=[2, 0], sigma=3 * sigma, absolute_sigma=True) perr = np.sqrt(np.diag(pcov)) assert_allclose(perr, [3 * 0.30714756, 3 * 0.85045308], rtol=1e-3) # infinite variances def f_flat(x, a, b): return a * x with warnings.catch_warnings(): # suppress warnings when testing with inf's warnings.filterwarnings('ignore', category=OptimizeWarning) popt, pcov = curve_fit(f_flat, xdata, ydata, p0=[2, 0], sigma=sigma) assert_(pcov.shape == (2, 2)) pcov_expected = np.array([np.inf] * 4).reshape(2, 2) assert_array_equal(pcov, pcov_expected) popt, pcov = curve_fit(f, xdata[:2], ydata[:2], p0=[2, 0]) assert_(pcov.shape == (2, 2)) assert_array_equal(pcov, pcov_expected)
def get_tau(autocorrelation): """ Parameters: ----------- autocorrelation: np.darray autocorrelation function of a given observable Return: ------- params: np.darray fitting parameters of autocorrelation onto an exponential decay """ N = len(autocorrelation)//2 x = np.arange(N) y = np.nan_to_num(autocorrelation[:N]) params, errors = curve_fit(func,x, y) return params
def test_regression_2639(self): # This test fails if epsfcn in leastsq is too large. x = [574.14200000000005, 574.154, 574.16499999999996, 574.17700000000002, 574.18799999999999, 574.19899999999996, 574.21100000000001, 574.22199999999998, 574.23400000000004, 574.245] y = [859.0, 997.0, 1699.0, 2604.0, 2013.0, 1964.0, 2435.0, 1550.0, 949.0, 841.0] guess = [574.1861428571428, 574.2155714285715, 1302.0, 1302.0, 0.0035019999999983615, 859.0] good = [5.74177150e+02, 5.74209188e+02, 1.74187044e+03, 1.58646166e+03, 1.0068462e-02, 8.57450661e+02] def f_double_gauss(x, x0, x1, A0, A1, sigma, c): return (A0*np.exp(-(x-x0)**2/(2.*sigma**2)) + A1*np.exp(-(x-x1)**2/(2.*sigma**2)) + c) popt, pcov = curve_fit(f_double_gauss, x, y, guess, maxfev=10000) assert_allclose(popt, good, rtol=1e-5)
def test_dtypes(self): # regression test for gh-9581: curve_fit fails if x and y dtypes differ x = np.arange(-3, 5) y = 1.5*x + 3.0 + 0.5*np.sin(x) def func(x, a, b): return a*x + b for method in ['lm', 'trf', 'dogbox']: for dtx in [np.float32, np.float64]: for dty in [np.float32, np.float64]: x = x.astype(dtx) y = y.astype(dty) with warnings.catch_warnings(): warnings.simplefilter("error", OptimizeWarning) p, cov = curve_fit(func, x, y, method=method) assert np.isfinite(cov).all() assert not np.allclose(p, 1) # curve_fit's initial value
def fitpol(x, y, guess=np.array([1, 90., 0.])): p, cov = curve_fit(polarized_intensity, x, y, p0=guess, Dfun=None, maxfev=500000, epsfcn=1.0e-9) if p[0] < 0: p[0] *= -1.0 while p[1] > 180.0: p[1] -= 180.0 while p[1] < 0.0: p[1] += 180.0 a = np.isinf(cov) if (a.all()): print 'Failed to fit a function' return p, cov