def T_effect(): strength_CB = [] strength_MC = [] m_arr = np.linspace(.5, 5., 30) for m in m_arr: # strengths.append(sigmac_max(l)[0]) # print 'strentgth = ', strengths[-1] w_CB = np.linspace(0.0, .5, 100) w_MC = np.linspace(0.0, .03, 100) sigma_c_CB = -sigmac( w_CB, 1000., RV('weibull_min', shape=m, scale=0.1, loc=0.0), 5.0) sigma_c_MC = -sigmac( w_MC, 1.0, RV('weibull_min', shape=m, scale=0.1, loc=0.0), 5.0) strength_CB.append(np.max(sigma_c_CB)) strength_MC.append(np.max(sigma_c_MC)) # plt.plot(w_CB, sigma_c_CB, label='CB') # plt.plot(w_CB, sigma_c_MC, label='MC') # plt.show() COV = [ np.sqrt(weibull_min(m, scale=0.1).var()) / weibull_min(m, scale=0.1).mean() for m in m_arr ] CB_arr = np.ones_like(np.array([strength_CB])) MC_arr = np.array([strength_MC]) / np.array([strength_CB]) plt.plot(COV, CB_arr.flatten()) plt.plot(COV, MC_arr.flatten()) plt.ylim(0) plt.show()
def plotQQBivariate(vData, dPar1, dPar2, sDistribution): if(sDistribution == 'Weibull'): st.probplot(vData, dist=st.weibull_min(dPar1,dPar2), plot=plt) elif(sDistribution == 'Gamma'): st.probplot(vData, dist=st.weibull_min(dPar1,dPar2), plot=plt) elif(sDistribution == 'Lognormal'): st.probplot(vData, dist=st.lognorm(dPar2,scale=np.exp(dPar1)), plot=plt)
def filaments_ld(): eps_fu = weibull_min(m, scale=s).ppf(np.linspace(0.001, 0.999, 50)) for eps in eps_fu: plt.plot([0, eps, eps], [0, eps * Ef, 0], color='grey') mu_eps = weibull_min(m, scale=s).stats('m') plt.plot([0, mu_eps, mu_eps], [0, mu_eps * Ef, 0], color='black', lw=3, ls='dashed')
def choose(self): if self.user_class == 'HF': self.name = "Log-norm" peak_hours_for_iat_hf = [1, 2, 3, 4, 5, 6] if self.hour in peak_hours_for_iat_hf: lognorm_shape, lognorm_scale, lognorm_location = 4.09174469261446, 1.12850165892419, 4.6875 else: lognorm_shape, lognorm_scale, lognorm_location = 3.93740014906562, 0.982210300411203, 3 return lognorm(lognorm_shape, loc=lognorm_location, scale=lognorm_scale) elif self.user_class == 'HO': self.name = "Gamma" peak_hours_for_iat_ho = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] if self.hour in peak_hours_for_iat_ho: gamma_shape, gamma_rate, gamma_location = 1.25170029089175, 0.00178381168026473, 0.5 else: gamma_shape, gamma_rate, gamma_location = 1.20448161464647, 0.00177591076721503, 0.5 return gamma(gamma_shape, loc=gamma_location, scale=1. / gamma_rate) elif self.user_class == 'MF': self.name = "Gamma" peak_hours_for_iat_mf = [1, 2, 3, 4, 5, 6, 7, 22, 23] if self.hour in peak_hours_for_iat_mf: gamma_shape, gamma_rate, gamma_location = 2.20816848575484, 0.00343216949000565, 1 else: gamma_shape, gamma_rate, gamma_location = 2.03011412986896, 0.00342699308280547, 1 return gamma(gamma_shape, loc=gamma_location, scale=1. / gamma_rate) elif self.user_class == 'MO': self.name = "Gamma" peak_hours_for_iat_mo = [1, 2, 3, 4, 5, 6] if self.hour in peak_hours_for_iat_mo: gamma_shape, gamma_rate, gamma_location = 1.29908195595742, 0.00163527376977441, 0.5 else: gamma_shape, gamma_rate, gamma_location = 1.19210494792398, 0.00170354443324898, 0.5 return gamma(gamma_shape, loc=gamma_location, scale=1. / gamma_rate) elif self.user_class == 'LF': peak_hours_for_iat_lf = [1, 2, 3, 4, 5, 6, 7] if self.hour in peak_hours_for_iat_lf: self.name = "Gamma" gamma_shape, gamma_rate, gamma_location = 1.79297773527656, 0.00191590321039876, 2 return gamma(gamma_shape, loc=gamma_location, scale=1. / gamma_rate) else: self.name = "Weibull" weibull_c_shape, weibull_scale, weibull_location = 1.1988117443903, 827.961760834184, 1 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'LO': peak_hours_for_iat_lo = [2, 3, 4, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20] if self.hour in peak_hours_for_iat_lo: self.name = "Weibull" weibull_c_shape, weibull_scale, weibull_location = 0.850890858519732, 548.241539446292, 1 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) else: self.name = "Gamma" gamma_shape, gamma_rate, gamma_location = 0.707816241615835, 0.00135537879658998, 1 return gamma(gamma_shape, loc=gamma_location, scale=1. / gamma_rate) else: raise Exception('The user class %s does not exist' % self.user_class)
def choose(self): if self.user_class == 'HF': self.name = "Log-norm" peak_hours_for_iat_hf = [1, 2, 3, 4, 5, 6] if self.hour in peak_hours_for_iat_hf: lognorm_shape, lognorm_scale, lognorm_location = 4.09174469261446, 1.12850165892419, 4.6875 else: lognorm_shape, lognorm_scale, lognorm_location = 3.93740014906562, 0.982210300411203, 3 return lognorm(lognorm_shape, loc = lognorm_location, scale = lognorm_scale) elif self.user_class == 'HO': self.name = "Gamma" peak_hours_for_iat_ho = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] if self.hour in peak_hours_for_iat_ho: gamma_shape, gamma_rate, gamma_location = 1.25170029089175, 0.00178381168026473, 0.5 else: gamma_shape, gamma_rate, gamma_location = 1.20448161464647, 0.00177591076721503, 0.5 return gamma(gamma_shape, loc = gamma_location, scale = 1./gamma_rate) elif self.user_class == 'MF': self.name = "Gamma" peak_hours_for_iat_mf = [1, 2, 3, 4, 5, 6, 7, 22, 23] if self.hour in peak_hours_for_iat_mf: gamma_shape, gamma_rate, gamma_location = 2.20816848575484, 0.00343216949000565, 1 else: gamma_shape, gamma_rate, gamma_location = 2.03011412986896, 0.00342699308280547, 1 return gamma(gamma_shape, loc = gamma_location, scale = 1./gamma_rate) elif self.user_class == 'MO': self.name = "Gamma" peak_hours_for_iat_mo = [1, 2, 3, 4, 5, 6] if self.hour in peak_hours_for_iat_mo: gamma_shape, gamma_rate, gamma_location = 1.29908195595742, 0.00163527376977441, 0.5 else: gamma_shape, gamma_rate, gamma_location = 1.19210494792398, 0.00170354443324898, 0.5 return gamma(gamma_shape, loc = gamma_location, scale = 1./gamma_rate) elif self.user_class == 'LF': peak_hours_for_iat_lf = [1, 2, 3, 4, 5, 6, 7] if self.hour in peak_hours_for_iat_lf: self.name = "Gamma" gamma_shape, gamma_rate, gamma_location = 1.79297773527656, 0.00191590321039876, 2 return gamma(gamma_shape, loc = gamma_location, scale = 1./gamma_rate) else: self.name = "Weibull" weibull_c_shape, weibull_scale, weibull_location = 1.1988117443903, 827.961760834184, 1 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'LO': peak_hours_for_iat_lo = [2, 3, 4, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20] if self.hour in peak_hours_for_iat_lo: self.name = "Weibull" weibull_c_shape, weibull_scale, weibull_location = 0.850890858519732, 548.241539446292, 1 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) else: self.name = "Gamma" gamma_shape, gamma_rate, gamma_location = 0.707816241615835, 0.00135537879658998, 1 return gamma(gamma_shape, loc = gamma_location, scale = 1./gamma_rate) else: raise Exception('The user class %s does not exist' % self.user_class)
def show_continuous(): """Show a variety of continuous distributions""" x = linspace(-10, 10, 201) # Normal distribution showDistribution(x, stats.norm, stats.norm(loc=2, scale=4), "Normal Distribution", "Z", "P(Z)", "") # Exponential distribution showDistribution(x, stats.expon, stats.expon(loc=-2, scale=4), "Exponential Distribution", "X", "P(X)", "") # Students' T-distribution # ... with 4, and with 10 degrees of freedom (DOF) plot(x, stats.norm.pdf(x), "g") hold(True) showDistribution(x, stats.t(4), stats.t(10), "T-Distribution", "X", "P(X)", ["normal", "t=4", "t=10"]) # F-distribution # ... with (3,4) and (10,15) DOF showDistribution(x, stats.f(3, 4), stats.f(10, 15), "F-Distribution", "F", "P(F)", ["(3,4) DOF", "(10,15) DOF"]) # Weibull distribution # ... with the shape parameter set to 1 and 2 # Don't worry that in Python it is called "weibull_min": the "weibull_max" is # simply mirrored about the origin. showDistribution( arange(0, 5, 0.02), stats.weibull_min(1), stats.weibull_min(2), "Weibull Distribution", "X", "P(X)", ["k=1", "k=2"], xmin=0, xmax=4, ) # Uniform distribution showDistribution(x, stats.uniform, "", "Uniform Distribution", "X", "P(X)", "") # Logistic distribution showDistribution(x, stats.norm, stats.logistic, "Logistic Distribution", "X", "P(X)", ["Normal", "Logistic"]) # Lognormal distribution x = logspace(-9, 1, 1001) + 1e-9 showDistribution(x, stats.lognorm(2), "", "Lognormal Distribution", "X", "lognorm(X)", "", xmin=-0.1) # The log-lin plot has to be done by hand: plot(log(x), stats.lognorm.pdf(x, 2)) xlim(-10, 4) title("Lognormal Distribution") xlabel("log(X)") ylabel("lognorm(X)") show()
def show_continuous(): """Show a variety of continuous distributions""" x = linspace(-10,10,201) # Normal distribution showDistribution(x, stats.norm, stats.norm(loc=2, scale=4), 'Normal Distribution', 'Z', 'P(Z)','') # Exponential distribution showDistribution(x, stats.expon, stats.expon(loc=-2, scale=4), 'Exponential Distribution', 'X', 'P(X)','') # Students' T-distribution # ... with 4, and with 10 degrees of freedom (DOF) plot(x, stats.norm.pdf(x), 'g-.') hold(True) showDistribution(x, stats.t(4), stats.t(10), 'T-Distribution', 'X', 'P(X)',['normal', 't=4', 't=10']) # F-distribution # ... with (3,4) and (10,15) DOF showDistribution(x, stats.f(3,4), stats.f(10,15), 'F-Distribution', 'F', 'P(F)',['(3,4) DOF', '(10,15) DOF']) # Weibull distribution # ... with the shape parameter set to 1 and 2 # Don't worry that in Python it is called "weibull_min": the "weibull_max" is # simply mirrored about the origin. showDistribution(arange(0,5,0.02), stats.weibull_min(1), stats.weibull_min(2), 'Weibull Distribution', 'X', 'P(X)',['k=1', 'k=2'], xmin=0, xmax=4) # Uniform distribution showDistribution(x, stats.uniform,'' , 'Uniform Distribution', 'X', 'P(X)','') # Logistic distribution showDistribution(x, stats.norm, stats.logistic, 'Logistic Distribution', 'X', 'P(X)',['Normal', 'Logistic']) # Lognormal distribution x = logspace(-9,1,1001)+1e-9 showDistribution(x, stats.lognorm(2), '', 'Lognormal Distribution', 'X', 'lognorm(X)','', xmin=-0.1) # The log-lin plot has to be done by hand: plot(log(x), stats.lognorm.pdf(x,2)) xlim(-10, 4) title('Lognormal Distribution') xlabel('log(X)') ylabel('lognorm(X)') show()
def show_continuous(): """Show a variety of continuous distributions""" x = np.linspace(-10,10,201) # Normal distribution showDistribution(x, stats.norm, stats.norm(loc=2, scale=4), 'Normal Distribution', 'Z', 'P(Z)','') # Exponential distribution showDistribution(x, stats.expon, stats.expon(loc=-2, scale=4), 'Exponential Distribution', 'X', 'P(X)','') # Students' T-distribution # ... with 4, and with 10 degrees of freedom (DOF) plt.plot(x, stats.norm.pdf(x), 'g-.') plt.hold(True) showDistribution(x, stats.t(4), stats.t(10), 'T-Distribution', 'X', 'P(X)',['normal', 't=4', 't=10']) # F-distribution # ... with (3,4) and (10,15) DOF showDistribution(x, stats.f(3,4), stats.f(10,15), 'F-Distribution', 'F', 'P(F)',['(3,4) DOF', '(10,15) DOF']) # Weibull distribution # ... with the shape parameter set to 1 and 2 # Don't worry that in Python it is called "weibull_min": the "weibull_max" is # simply mirrored about the origin. showDistribution(np.arange(0,5,0.02), stats.weibull_min(1), stats.weibull_min(2), 'Weibull Distribution', 'X', 'P(X)',['k=1', 'k=2'], xmin=0, xmax=4) # Uniform distribution showDistribution(x, stats.uniform,'' , 'Uniform Distribution', 'X', 'P(X)','') # Logistic distribution showDistribution(x, stats.norm, stats.logistic, 'Logistic Distribution', 'X', 'P(X)',['Normal', 'Logistic']) # Lognormal distribution x = np.logspace(-9,1,1001)+1e-9 showDistribution(x, stats.lognorm(2), '', 'Lognormal Distribution', 'X', 'lognorm(X)','', xmin=-0.1) # The log-lin plot has to be done by hand: plt.plot(np.log(x), stats.lognorm.pdf(x,2)) plt.xlim(-10, 4) plt.title('Lognormal Distribution') plt.xlabel('log(X)') plt.ylabel('lognorm(X)') plt.show()
def getMargin(comps): # this implementation: only Beta, Weibull and Multinomial (cat) mtype = comps['mtype'] params = comps['params'] c_nr = comps['comps_nr'] if mtype == 'Beta': dists = [] for c_id in range(c_nr): #labels = ['a','b'] param = params[c_id][:2] dist = stt.beta(a=param[0], b=param[1]) dists.append(dist) elif mtype == 'Weibull': dists = [] for c_id in range(comps['comps_nr']): #labels = ['c','scale'] param = [params[(p_id * c_nr) + c_id] for p_id in range(2)] dist = stt.weibull_min(param[0], 0., param[1]) dists.append(dist) elif mtype == 'Multinomial': # IMPLEMENTAR dists = [stt.multinomial(1, params)] try: dists[0].interval(1.) except: domain = [] else: domains = np.array( [dists[d_id].interval(1.) for d_id in range(len(dists))]) domain_raw = [domains[:, 0].max(), domains[:, 1].min()] delta = 0.001 * (domain_raw[1] - domain_raw[0]) domain = [domain_raw[0] + delta, domain_raw[1] - delta] return dists, domain
def _get_weibull_dist(self, qty, mean=None, std=None, scale=1.0, shape=5.0): x_line = np.arange(mean - std * 4.0, mean + std * 5.0, 1 * std) if self.weibull_dist_method == 'double': _data = dweibull(shape, loc=mean, scale=std) y_line = _data.pdf(x_line) * qty if self.weibull_dist_method == 'inverted': _data = invweibull(shape, loc=mean, scale=std) y_line = _data.pdf(x_line) * qty if self.weibull_dist_method == 'exponential': _data = exponweib(scale, shape, loc=mean, scale=std) y_line = _data.pdf(x_line) * qty if self.weibull_dist_method == 'min': _data = weibull_min(shape, loc=mean, scale=std) y_line = _data.pdf(x_line) * qty if self.weibull_dist_method == 'max': _data = weibull_max(shape, loc=mean, scale=std) y_line = _data.pdf(x_line) * qty line = Line(width=1280, height=600) line.add(u'{0}'.format(self.spc_target), x_line, y_line, xaxis_name=u'{0}'.format(self.spc_target), yaxis_name=u'数量(Quantity)', line_color='rgba(0 ,255 ,127,0.5)', legend_pos='center', is_smooth=True, line_width=2, tooltip_tragger='axis', is_fill=True, area_color='#20B2AA', area_opacity=0.4) pyecharts.configure(force_js_embed=True) return line.render_embed()
def bundle_comparison(w_arr, L, shape, scale, E): '''bundle (Weibull fibers) response for comparison with the CB model''' from scipy.stats import weibull_min sV0 = scale * (3.14159 * 0.00345**2 * L)**(1 / shape) eps = w_arr / L * (1. - weibull_min(shape, scale=scale).cdf(w_arr / L)) plt.plot(w_arr / L, eps * E, lw=4, color='red', ls='dashed', label='FB model') bundle = Reinforcement(r=0.00345, tau=0.00001, V_f=0.9999, E_f=E, xi=WeibullFibers(shape=shape, sV0=sV0), n_int=50) ccb = CompositeCrackBridge(E_m=25e3, reinforcement_lst=[bundle], Ll=L / 2., Lr=L / 2.) ccb_view.model = ccb eps = [] for w in w_arr: ccb.w = w eps.append(ccb_view.sigma_c / E) plt.plot(w_arr / L, np.array(eps) * E, color='blue', lw=2, label='CB model') plt.legend(loc='best')
def _get_random_field(self): if self.seed == True: np.random.seed(101) '''simulates the Gaussian random field''' # evaluate the eigenvalues and eigenvectors of the autocorrelation # matrix _lambda, phi = self.eigenvalues # simulation points from 0 to 1 with an equidistant step for the LHS randsim = linspace(0, 1, len(self.xgrid) + 1) - 0.5 / (len(self.xgrid)) randsim = randsim[1:] # shuffling points for the simulation shuffle(randsim) # matrix containing standard Gauss distributed random numbers xi = transpose( ones((self.nsim, len(self.xgrid))) * array([norm().ppf(randsim)])) # eigenvalue matrix LAMBDA = eye(len(self.xgrid)) * _lambda # cutting out the real part ydata = dot(dot(phi, (LAMBDA) ** 0.5), xi).real if self.distr_type == 'Gauss': # scaling the std. distribution scaled_ydata = ydata * self.stdev + self.mean elif self.distr_type == 'Weibull': # setting Weibull params Pf = norm().cdf(ydata) scaled_ydata = weibull_min( self.shape, scale=self.scale, loc=self.loc).ppf(Pf) self.reevaluate = False rf = reshape(scaled_ydata, len(self.xgrid)) if self.non_negative_check == True: if (rf < 0).any(): raise ValueError, 'negative value(s) in random field' return rf
def plot_weibull_fit(data, fit_results, title=None, x_label=None, x_range=None, y_range=None, fig_size=(6, 5), bin_width=None, filename=None): """ :param data: (numpy.array) observations :param fit_results: dictionary with keys "c", "scale" and "loc" :param title: title of the figure :param x_label: label to show on the x-axis of the histogram :param x_range: (tuple) x range :param y_range: (tuple) y range (the histogram shows the probability density so the upper value of y_range should be 1). :param fig_size: int, specify the figure size :param bin_width: bin width :param filename: filename to save the figure as """ plot_fit_continuous(data=data, dist=stat.weibull_min(c=fit_results['c'], scale=fit_results['scale'], loc=fit_results['loc']), label='Weibull', bin_width=bin_width, title=title, x_label=x_label, x_range=x_range, y_range=y_range, fig_size=fig_size, filename=filename)
def weibull(): sigma = linspace( 0, 2300., 300 ) CDF = weibull_min( se.m_f, scale = se.s( 0.2 ) ).cdf( sigma ) plt.plot( sigma, CDF, lw = 2, color = 'black', label = 'filament: Weibull min. distr.' ) plt.xlabel( 'stress [$\mathrm{N/mm^2}$]', size = 'large' ) plt.ylabel( 'prob. of failure', size = 'large' ) plt.title( 'CDF at gauge length 200 mm', fontsize = 20 )
def interpolate_rf(self, coords): '''interpolate RF values using the EOLE method coords = list of 1d arrays of coordinates''' # check consistency of dimensions if len(coords) != len(self.nDgrid): raise ValueError('point dimension differs from random field dimension') # create the covariance matrix C_matrices = [self.acor(coords_i.reshape(1, len(coords_i)) - self.nDgrid[i].reshape(len(self.nDgrid[i]),1), self.lacor_arr[i]) for i, coords_i in enumerate(coords)] C_u = 1.0 for i, C_ui in enumerate(C_matrices): if i == 0: C_u *= C_ui else: C_u = C_u.reshape(C_u.shape[0], 1, C_u.shape[1]) * C_ui grid_size = 1.0 for j in np.arange(i+1): grid_size *= len(self.nDgrid[j]) C_u = C_u.reshape(grid_size,len(coords[0])) Lambda_Cx, Phi_Cx = self.eigenvalues # values interpolated in the standardized Gaussian rf u = np.sum(self.generated_random_vector / np.diag(Lambda_Cx) ** 0.5 * np.dot(C_u.T, Phi_Cx), axis=1) if self.distr_type == 'Gauss': scaled_u = u * self.stdev + self.mean elif self.distr_type == 'Weibull': Pf = norm().cdf(u) scaled_u = weibull_min(self.shape, scale=self.scale, loc=self.loc).ppf(Pf) return scaled_u
def bundle_ld(): e = np.linspace(0.0, 1.5 * s, 1000) plt.plot(e, e * Ef * (1 - weibull_min(m, scale=s).cdf(e)), color='black', lw=3) plt.xlim(0, 1.6 * s)
def _get_random_field(self): if self.seed == True: np.random.seed(101) '''simulates the Gaussian random field''' # evaluate the eigenvalues and eigenvectors of the autocorrelation # matrix _lambda, phi = self.eigenvalues # simulation points from 0 to 1 with an equidistant step for the LHS randsim = linspace(0, 1, len(self.xgrid) + 1) - 0.5 / (len(self.xgrid)) randsim = randsim[1:] # shuffling points for the simulation shuffle(randsim) # matrix containing standard Gauss distributed random numbers xi = transpose( ones((self.nsim, len(self.xgrid))) * array([norm().ppf(randsim)])) # eigenvalue matrix LAMBDA = eye(len(self.xgrid)) * _lambda # cutting out the real part ydata = dot(dot(phi, (LAMBDA) ** 0.5), xi).real if self.distr_type == 'Gauss': # scaling the std. distribution scaled_ydata = ydata * self.stdev + self.mean elif self.distr_type == 'Weibull': # setting Weibull params Pf = norm().cdf(ydata) scaled_ydata = weibull_min( self.shape, scale=self.scale, loc=self.loc).ppf(Pf) self.reevaluate = False rf = reshape(scaled_ydata, len(self.xgrid)) if self.non_negative_check == True: if (rf < 0).any(): raise ValueError('negative value(s) in random field') return rf
def setDistObj(self): """ create and freeze the distribution object from the stats module with the current scale, locationa nd shape parameters """ if self.type == 'normal': self.distObj = stats.norm(loc=self.loc, scale=self.scale) elif self.type == 'lognormal': self.distObj = stats.lognorm(s=self.shape, loc=self.loc, scale=self.scale) elif self.type == 'weibull': self.distObj = stats.weibull_min(c=self.shape, loc=self.loc, scale=self.scale) elif self.type == 'exponential': self.distObj = stats.expon(loc=self.loc, scale=self.scale) elif self.type == 'triangular': self.distObj = stats.triang(c=self.shape, loc=self.loc, scale=self.scale) elif self.type == 'uniform': self.distObj = stats.uniform(loc=self.loc, scale=self.scale) elif self.type == 'gamma': self.distObj = stats.gamma(a=self.shape, loc=self.loc, scale=self.scale) # elif self.type == 'constant': # self.value = float(settings[self.name + '_' + 'value']) return
def toggle_slider_vis(self): if len(graphList) > 0 and None not in graphList: for axis in graphList: axis.set_visible(not axis.get_visible()) if not graphList[0].get_visible(): allAxes = figure.get_axes() for ax in allAxes: if ax == maximizedAxis: ax.clear() if toMaximizeType == 'weibull plot': c = toMaximize[1] x = toMaximize[2] # maximizedAxis.set_xscale("log", nonposx='clip') weibull = ss.weibull_min(c) (quantiles, values), (slope, intercept, r) = ss.probplot(x, dist=weibull) maximizedAxis.plot(values, quantiles, 'ob') maximizedAxis.plot(quantiles * slope + intercept, quantiles, 'r') ticks_perc = [1, 5, 10, 20, 50, 80, 90, 95, 99, 99.9] ticks_quan = [ ss.weibull_min.ppf(i / 100., c) for i in ticks_perc ] maximizedAxis.yaxis.set_ticklabels( ticks_perc) #Set the text values of the tick labels. maximizedAxis.yaxis.set_ticks(ticks_quan) self.popup_menu.entryconfigure(0, label="Restore") else: self.popup_menu.entryconfigure(0, label="Maximize") maximizedAxis.set_visible(not maximizedAxis.get_visible()) self.draw()
def weibull(data): shape, loc, scale = s.weibull_min.fit(data, floc=0) wei = s.weibull_min(shape, loc, scale) # x=np.linspace(np.min(obs),np.max(obs)) # plt.hist(obs,normed=True,fc="none",ec="grey",label="frequency") # plt.plot(x,wei.cdf(x),label="cdf") # plt.plot(x,wei.pdf(x),label="pdf") return wei
def part1(): sample = np.loadtxt('выборка_скорости_ветра_из_задания_2.txt') shape, loc, scale = sps.weibull_min.fit(sample, floc=0) print(shape, loc, scale) kstatisics, pvalue = sps.kstest(sample, sps.weibull_min(shape, scale=scale).cdf) print(kstatisics, pvalue)
def best_likelihood(grid, sample): # плотности распределения Вейбулла в точках grid logpdf = sps.weibull_min(c=grid[0], scale=grid[1]).logpdf # функции правдоподобия в точках grid logpdfs = logpdf(sample[:, np.newaxis, np.newaxis]) likelihood = logpdfs.sum(axis=0) # индекс сетки, в котором функция правдоподобия максимальна argmax = cool_argmax(likelihood) # (k, λ) return grid[0][argmax], grid[1][argmax]
def __init__(self, name,mean,stdv,epsilon=0,input_type=None,startpoint=None): self.type = 16 self.distribution = {16:'Weibull'} self.name = name self.mean = mean self.stdv = stdv self.epsilon = epsilon self.input_type = input_type mean,stdv,p1,p2,p3,p4 = self.setMarginalDistribution() Distribution.__init__(self,name,self.type,mean,stdv,startpoint,p1,p2,p3,p4,input_type) self.rv = stats.weibull_min(c=p2, scale=p1-p3, loc=p3)
def __init__(self, scale=None, shape=None): self.shape = shape self.scale = scale if (self.scale is not None) and (self.shape is not None): if ( self.shape > 0.0 ) and (self.scale > 0.0): self.mean = self.scale * gamma(1.0 + 1.0/self.shape) self.variance = self.scale**2 * ( gamma(1.0 + 2.0/self.shape) - (gamma(1.0 + 1.0/self.shape))**2 ) self.parent = weibull_min(c =self.shape, scale=self.scale) self.skewness = (gamma(1.0 + 3.0/self.shape) * self.scale**3 - 3 * self.mean * self.variance - self.mean**3 )/( np.sqrt(self.variance)**3 ) self.bounds = np.array([0, np.inf]) self.x_range_for_pdf = np.linspace(10**(-15), 30.0, RECURRENCE_PDF_SAMPLES)
def _get_random_field( self ): '''generates an array of random matrix strength''' np = int( self.length / self.l_rho ) if np <= 3: np = 4 print np x_not_corr_points = linspace( 0, np * self.l_rho, np) y_not_corr_points = weibull_min( self.m, scale = self.scale_sigma_m ).ppf( rand( np ) ) spline = InterpolatedUnivariateSpline( x_not_corr_points, y_not_corr_points ) return spline( self.x_arr )
def simulate_data_with_births(samp_size, wei_params, start, percent_adult, max_days): """ Simulate pig infection data based on a Weibull distribution and a uniform DOB distribution with sum percent of pigs being born before the the interval of interest (adults) Parameters ---------- samp_size : int Total number of hosts to sample wei_params : tuple alpha, sigma parameters of Weibull distribution start : pd.DateTime The start date of the infection season percent_adult : float Percent of pigs that are adults i.e. could be infected before the start of sampling. max_days : int The number of days from the start of the infection season at which the season ends Returns ------- : DataFrame Infection times, infection indicator, sample_date, dob """ wei = stats.weibull_min(wei_params[0], scale=wei_params[1]) adults = np.int(samp_size * percent_adult) dobs = np.append(np.repeat(0, adults), stats.uniform(loc=0, scale=max_days).rvs(size=samp_size - adults)) upper_prob = wei.cdf(max_days) lower_probs = wei.cdf(dobs) inf_probs = upper_prob - lower_probs inf = stats.binom.rvs(1, inf_probs, size=len(inf_probs)) # For each infected individual draw a toi unifrand = stats.uniform.rvs(loc=lower_probs, scale=upper_prob - lower_probs, size=len(inf_probs)) toi_samp = wei.ppf(unifrand) sampling_time = stats.uniform(loc=dobs, scale=max_days - dobs).rvs(size=samp_size) eventobserved = ((sampling_time > toi_samp) & (inf == 1)).astype(np.int) time = np.where(eventobserved == 1, toi_samp, sampling_time) surv_df = pd.DataFrame(dict(time_in_season=time, infection=eventobserved == 1, sample_date = start + pd.to_timedelta(sampling_time, unit="D"), dob=start + pd.to_timedelta(dobs, unit="D"))) return(surv_df)
def single_determ_filament(): # SINGLE DETERMINISTIC FILAMENT w_arr = np.linspace(0.0, 0.5, 500) micro = GFRCMicro(FilamentCB=CBShortFiber) theta_dict = dict(tau=0.2, r=3.5e-3, E_f=70e3, le=9.0, phi=1.0, snub=0.5, xi=1e10, spall=0.5) for i in range(10): tau_i = uniform(loc=0.001, scale=0.4).rvs(1) xi_i = weibull_min(5.0, scale=0.025).rvs(1) theta_dict["xi"] = float(xi_i) theta_dict["tau"] = float(tau_i) mean_resp = micro.mean_response(w_arr, theta_dict) plt.plot(w_arr, mean_resp, lw=1) plt.show()
def test_weibull_rayleigh(): lambda_ = 11 rayleigh = cp.Rayleigh(scale=lambda_) r0, r1 = rayleigh.range() x = np.linspace(r0, r1, 300, endpoint=True) weibull = cp.Weibull(shape=2, scale=lambda_*math.sqrt(2)) weibull_sp = stats.weibull_min(2, scale=lambda_*math.sqrt(2)) np.testing.assert_allclose(weibull_sp.pdf(x), weibull.pdf(x), atol=1e-08) np.testing.assert_allclose(rayleigh.pdf(x), weibull.pdf(x), atol=1e-08) np.testing.assert_allclose(rayleigh.fwd(x), weibull.fwd(x), atol=1e-08)
def test_weibull_rayleigh(): lambda_ = 11 rayleigh = cp.Rayleigh(scale=lambda_) r0, r1 = rayleigh.range() x = np.linspace(r0, r1, 300, endpoint=True) weibull = cp.Weibull(shape=2, scale=lambda_ * math.sqrt(2)) weibull_sp = stats.weibull_min(2, scale=lambda_ * math.sqrt(2)) np.testing.assert_allclose(weibull_sp.pdf(x), weibull.pdf(x), atol=1e-08) np.testing.assert_allclose(rayleigh.pdf(x), weibull.pdf(x), atol=1e-08) np.testing.assert_allclose(rayleigh.fwd(x), weibull.fwd(x), atol=1e-08)
def choose(self): self.name = "Weibull" if self.user_class == 'HF': peak_hours_for_volume_hf = [10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_hf: weibull_c_shape, weibull_scale, weibull_location = 0.819409132355671, 774639.610211396, 40 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) else: weibull_c_shape, weibull_scale, weibull_location = 0.634477150024807, 384935.669023795, 40 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'HO': peak_hours_for_volume_ho = [1, 2, 6, 7, 8, 9, 10, 14, 15, 16, 17, 18, 19, 21] if self.hour in peak_hours_for_volume_ho: weibull_c_shape, weibull_scale, weibull_location = 0.498273622342091, 476551.703412746, 30 else: weibull_c_shape, weibull_scale, weibull_location = 0.507073160695169, 452332.836400453, 30 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'MF': peak_hours_for_volume_mf = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] if self.hour in peak_hours_for_volume_mf: weibull_c_shape, weibull_scale, weibull_location = 0.801202265360056, 13959.452422549, 37 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) else: weibull_c_shape, weibull_scale, weibull_location = 0.797283673532605, 10657.9935943482, 33 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'MO': peak_hours_for_volume_mo = [1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_mo: weibull_c_shape, weibull_scale, weibull_location = 0.596142171663733, 31936.8353050143, 29 else: weibull_c_shape, weibull_scale, weibull_location = 0.588535361156048, 26617.7612810844, 30 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'LF': peak_hours_for_volume_lf = [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] if self.hour in peak_hours_for_volume_lf: weibull_c_shape, weibull_scale, weibull_location = 0.926450022452343, 1181.70293939011, 33 else: weibull_c_shape, weibull_scale, weibull_location = 1.03429757728009, 873.579218199549, 34 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) elif self.user_class == 'LO': peak_hours_for_volume_lo = [1, 3, 4, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_lo: weibull_c_shape, weibull_scale, weibull_location = 0.856409898006734, 3228.75558535546, 29 else: weibull_c_shape, weibull_scale, weibull_location = 0.797856625454382, 2800.11615587819, 29 return weibull_min(weibull_c_shape, loc=weibull_location, scale=weibull_scale) else: raise Exception('The user class %s does not exist' % self.user_class)
def choose(self): self.name = "Weibull" if self.user_class == 'HF': peak_hours_for_volume_hf = [10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_hf: weibull_c_shape, weibull_scale, weibull_location = 0.819409132355671, 774639.610211396, 40 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) else: weibull_c_shape, weibull_scale, weibull_location = 0.634477150024807, 384935.669023795, 40 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'HO': peak_hours_for_volume_ho = [1, 2, 6, 7, 8, 9, 10, 14, 15, 16, 17, 18, 19, 21] if self.hour in peak_hours_for_volume_ho: weibull_c_shape, weibull_scale, weibull_location = 0.498273622342091, 476551.703412746, 30 else: weibull_c_shape, weibull_scale, weibull_location = 0.507073160695169, 452332.836400453, 30 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'MF': peak_hours_for_volume_mf = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] if self.hour in peak_hours_for_volume_mf: weibull_c_shape, weibull_scale, weibull_location = 0.801202265360056, 13959.452422549, 37 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) else: weibull_c_shape, weibull_scale, weibull_location = 0.797283673532605, 10657.9935943482, 33 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'MO': peak_hours_for_volume_mo = [1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_mo: weibull_c_shape, weibull_scale, weibull_location = 0.596142171663733, 31936.8353050143, 29 else: weibull_c_shape, weibull_scale, weibull_location = 0.588535361156048, 26617.7612810844, 30 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'LF': peak_hours_for_volume_lf = [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] if self.hour in peak_hours_for_volume_lf: weibull_c_shape, weibull_scale, weibull_location = 0.926450022452343, 1181.70293939011, 33 else: weibull_c_shape, weibull_scale, weibull_location = 1.03429757728009, 873.579218199549, 34 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) elif self.user_class == 'LO': peak_hours_for_volume_lo = [1, 3, 4, 19, 20, 21, 22, 23] if self.hour in peak_hours_for_volume_lo: weibull_c_shape, weibull_scale, weibull_location = 0.856409898006734, 3228.75558535546, 29 else: weibull_c_shape, weibull_scale, weibull_location = 0.797856625454382, 2800.11615587819, 29 return weibull_min(weibull_c_shape, loc = weibull_location, scale = weibull_scale) else: raise Exception('The user class %s does not exist' % self.user_class)
def init_winds(self): for key, val in self.months.items(): lam = val[0] k = val[1] # Creating the wind distribution for a month wind_distribution = weibull_min(k, loc=0, scale=lam) # Generate wind wind = wind_distribution.rvs(size=self.n) self.winds[key] = {"wind": wind, "dist": wind_distribution}
def KSTestCDFPlot(Stat_Stn, Stn, Setting): MonthlyStat = Stat_Stn["MonthlyStat"] Prep = Stat_Stn["PrepDF"]["P"] fig, axs = plt.subplots(nrows=4, ncols=3, sharex=True, sharey=True) m = 0 for i in range(3): for j in range(4): Prep_m = Prep[Prep.index.month == (m + 1)].dropna() Prep_m = Prep_m[Prep_m != 0] coef1 = MonthlyStat.loc[m + 1, "exp"] coef2 = MonthlyStat.loc[m + 1, "gamma"] coef3 = MonthlyStat.loc[m + 1, "weibull"] coef4 = MonthlyStat.loc[m + 1, "lognorm"] # Plot ecdf = ECDF(Prep_m) x = np.arange(0, max(Prep_m), 0.1) axs[j, i].plot(x, expon(coef1[0], coef1[1]).cdf(x), label='exp', linestyle=':') axs[j, i].plot(x, gamma(coef2[0], coef2[1], coef2[2]).cdf(x), label='gamma', linestyle=':') axs[j, i].plot(x, weibull_min(coef3[0], coef3[1], coef3[2]).cdf(x), label='weibull', linestyle=':') xlog = np.arange(min(np.log(Prep_m)), max(np.log(Prep_m)), 0.1) axs[j, i].plot(np.exp(xlog), norm(coef4[0], coef4[1]).cdf(xlog), label='lognorm', linestyle=':') axs[j, i].plot(ecdf.x, ecdf.y, label='ecdf', color="red") axs[j, i].axvline(x=130, color="black", linestyle="--", linewidth=1) # Definition of storm defined by CWB axs[j, i].set_title(str(m + 1)) axs[j, i].legend() m += 1 fig.suptitle("KStest CDF " + Stn, fontsize=16) # Add common axis label fig.text(0.5, 0.04, 'Precipitation (mm)', ha='center', fontsize=14) fig.text(0.05, 0.5, 'CDF', va='center', rotation='vertical', fontsize=14) fig.set_size_inches(18.5, 10.5) plt.tight_layout(rect=[0.06, 0.05, 0.94, 0.94]) #rect : tuple (left, bottom, right, top) SaveFig(fig, "KStest CDF " + Stn, Setting) plt.show() return None
def T_effect(): strength_CB = [] strength_MC = [] m_arr = np.linspace(.5, 5., 30) for m in m_arr: # strengths.append(sigmac_max(l)[0]) # print 'strentgth = ', strengths[-1] w_CB = np.linspace(0.0, .5, 100) w_MC = np.linspace(0.0, .03, 100) sigma_c_CB = -sigmac(w_CB, 1000., RV('weibull_min', shape=m, scale=0.1, loc=0.0), 5.0) sigma_c_MC = -sigmac(w_MC, 1.0, RV('weibull_min', shape=m, scale=0.1, loc=0.0), 5.0) strength_CB.append(np.max(sigma_c_CB)) strength_MC.append(np.max(sigma_c_MC)) # plt.plot(w_CB, sigma_c_CB, label='CB') # plt.plot(w_CB, sigma_c_MC, label='MC') # plt.show() COV = [np.sqrt(weibull_min(m, scale=0.1).var()) / weibull_min(m, scale=0.1).mean() for m in m_arr] CB_arr = np.ones_like(np.array([strength_CB])) MC_arr = np.array([strength_MC]) / np.array([strength_CB]) plt.plot(COV, CB_arr.flatten()) plt.plot(COV, MC_arr.flatten()) plt.ylim(0) plt.show()
def maximum_likelihood( data ): params = fmin( maxlike, [2., 5.], args = ( data ) ) moments = weibull_min( params[0], scale = params[1], loc = 0. ).stats( 'mv' ) print ' #### max likelihood #### ' print 'mean = ', moments[0] print 'var = ', moments[1] print 'Weibull shape = ', params[0] print 'Weibull scale = ', params[1] # plot the Weibull fit according to maximum likelihood e = linspace( 0., 0.3 * ( max( data ) - min( data ) ) + max( data ), 100 ) #plt.plot( e, weibull_min.pdf( e, params[0], scale = params[1], loc = 0. ), #color = 'red', linewidth = 2, label = 'max likelihood' ) plt.xlabel( 'Risspannung $\sigma_{c,u}$' , fontsize = 20 ) plt.ylabel( 'PDF', fontsize = 20 )
def simulation(e_max): T = 2. * tau / r / Ef a = e_max / T nz = 500 z_arr = np.linspace(a/2./nz, a - a/2./nz, nz) eps = e_max - T * z_arr dz = a/nz fu_arr = weibull_min(m, scale=s * (dz/L0)**(-1./m)).ppf(np.minimum(np.random.rand(nz), np.random.rand(nz))) max_diff = np.max(eps - fu_arr) if max_diff > 0.0: L = z_arr[np.argmax(eps - fu_arr)] eu = e_max - max_diff return L, eu else: return None, None
def get_distr_residuum( params, mean, stdev, skew ): print 'maan',mean,'variance',stdev print params shape = params[0] loc = params[1] scale = params[2] mom_eq = stats.weibull_min( shape, loc = loc, scale = scale, moments = 'mvs' ) moms = mom_eq.stats() print '---------------------------------' print moms mean_resid = moms[0] - mean stdev_resid = sqrt( moms[1] ) - stdev skew_resid = moms[2] - skew print 'mean', moms[0], 'stdev', sqrt( moms[1] ) return ( mean_resid, stdev_resid, skew_resid )
def simulation(e_max): T = 2. * tau / r / Ef a = e_max / T nz = 500 z_arr = np.linspace(a / 2. / nz, a - a / 2. / nz, nz) eps = e_max - T * z_arr dz = a / nz fu_arr = weibull_min(m, scale=s * (dz / L0)**(-1. / m)).ppf( np.minimum(np.random.rand(nz), np.random.rand(nz))) max_diff = np.max(eps - fu_arr) if max_diff > 0.0: L = z_arr[np.argmax(eps - fu_arr)] eu = e_max - max_diff return L, eu else: return None, None
def random_domain(w): Ef = 70e3 Fxi = weibull_min(5., scale = 0.02) r = np.linspace(0.001, 0.005, 100) tau = np.linspace(0., 1., 100) e_arr = orthogonalize([np.arange(len(r)), np.arange(len(tau))]) tau = tau.reshape(1, len(tau)) r = r.reshape(len(r), 1) eps0 = np.sqrt(w * 2 * tau / r / Ef) F = Fxi.cdf(eps0) a = r * Ef / 2. / tau m.surf(e_arr[0], e_arr[1], 50 * F / np.max(F)) m.surf(e_arr[0], e_arr[1], 50 * eps0 / np.max(eps0)) m.surf(e_arr[0], e_arr[1], np.nan_to_num(a) / 100.) m.show()
def plot_distribution(): size = 100000 x = stats.norm(loc=42.0, scale=5).rvs(size=size) # (stats.norm(loc=-5, scale=1), False), #(stats.lognorm(scale=np.exp(-5), s=1), True) # worse conv of higher moments # (stats.lognorm(scale=np.exp(-5), s=0.5), True) # worse conv of higher moments # (stats.chi2(df=10), True) x = stats.weibull_min(c=3).rvs(size=size) # Exponential # (stats.weibull_min(c=1.5), True) # Infinite derivative at zero # (stats.weibull_min(c=3), True) # Close to normal print("t mean ", np.mean(x)) print("t var ", np.var(x)) print("delka t ", len(x)) plt.hist(x, bins=10000, normed=1) plt.show() exit()
def __init__(self, scale=None, shape=None): self.shape = shape self.scale = scale if (self.scale is not None) and (self.shape is not None): if (self.shape > 0.0) and (self.scale > 0.0): self.mean = self.scale * gamma(1.0 + 1.0 / self.shape) self.variance = self.scale**2 * ( gamma(1.0 + 2.0 / self.shape) - (gamma(1.0 + 1.0 / self.shape))**2) self.parent = weibull_min(c=self.shape, scale=self.scale) self.skewness = (gamma(1.0 + 3.0 / self.shape) * self.scale**3 - 3 * self.mean * self.variance - self.mean**3) / (np.sqrt(self.variance)**3) self.bounds = np.array([0, np.inf]) self.x_range_for_pdf = np.linspace(10**(-15), 30.0, RECURRENCE_PDF_SAMPLES)
def proper_truncated_weibull(upper_truncation_threshold, lower_truncation_threshold, k=3.353, scale_factor=0.612): dist = weibull_min(c=k, scale=scale_factor) upper_value, lower_value = dist.cdf( (upper_truncation_threshold, lower_truncation_threshold)) dist_range = upper_value - lower_value val = (dist.cdf( np.random.uniform(lower_truncation_threshold, upper_truncation_threshold)) - lower_value) / dist_range # if val < lower_truncation_threshold or val > upper_truncation_threshold: # print("Broken") # print(val, dist_range, upper_value, lower_value, upper_truncation_threshold, lower_truncation_threshold) return val
def _get_random_field(self): '''simulates the Gaussian random field''' # evaluate the eigenvalues and eigenvectors of the autocorrelation matrix Lambda_C_sorted, Phi_C_sorted = self.eigenvalues # generate the RF with standardized Gaussian distribution ydata = np.dot(np.dot(Phi_C_sorted, (Lambda_C_sorted) ** 0.5), self.generated_random_vector) # transform the standardized Gaussian distribution if self.distr_type == 'Gauss': # scaling the std. distribution scaled_ydata = ydata * self.stdev + self.mean elif self.distr_type == 'Weibull': # setting Weibull params Pf = norm().cdf(ydata) scaled_ydata = weibull_min(self.shape, scale=self.scale, loc=self.loc).ppf(Pf) shape = tuple([len(grid_i) for grid_i in self.nDgrid]) rf = np.reshape(scaled_ydata, shape) return rf
def part2(): grid = np.linspace(0, 10, 500) # гистограмма plt.hist(sample, 20, range=(grid.min(), grid.max()), normed=True, label='histogram') # истинная плотность plt.plot(grid, sps.weibull_min(c=k, scale=λ).pdf(grid), color='red', linewidth=2, alpha=0.3, label='true pdf') plt.legend() plt.show()
def compute_bins(vmin, vmax, maxbin, c, k): """ Finds bin boundaries with maximum `vmax`, minimum `vmin` and max bin size `maxbin`. Also returns the weibull cumulative distribution probability of each bin with shape factor `c` and scale factor `k`. Parameters ---------- vmin : int | float Range minimum. vmax : int | float Range maximum. maxbin : int | float Maximum bin width. c : int | float Weibull shape factor. k : int | float Weibull scale factor. Returns ------- int Number of bins. float Bin width. list List of upper boundaries of each bin. np.array Weibull probability of each bin. """ num_bins = int(np.ceil((vmax - vmin) / maxbin)) probabilities = np.zeros(num_bins) width = (vmax - vmin) / num_bins upper_bounds = [] for i in range(num_bins): bot = vmin + i * width top = bot + width upper_bounds.append(top) dist = weibull_min(c, scale=k) probabilities[i] = dist.cdf(top) - dist.cdf(bot) return num_bins, width, upper_bounds, probabilities
def maximum_likelihood(self, plot = True): data = self.data params = fmin(self.maxlike, np.array([10., np.mean(data)])) moments = weibull_min(params[0], scale = params[1], loc = 0.).stats('mv') print ' #### max likelihood #### ' print 'mean = ', moments[0] print 'var = ', moments[1] print 'Weibull shape = ', params[0] print 'Weibull scale = ', params[1] #print 'scale sV0 = ', params[1] * (pi * 13.e-3**2 * self.length)**(1./params[0]) if plot == True: # plot the Weibull fit according to maximum likelihood e = np.linspace(0., 0.3 * (np.max(data) - np.min(data)) + np.max(data), 100) plt.plot(e, weibull_min.pdf(e, params[0], scale = params[1], loc = 0.), color = 'red', linewidth = 2, label = 'max likelihood') plt.xlabel('strain') plt.ylabel('PDF') return params[0], params[1]
def bundle_comparison(w_arr, L, shape, scale, E): '''bundle (Weibull fibers) response for comparison with the CB model''' from scipy.stats import weibull_min eps = w_arr / L * (1. - weibull_min(shape, scale=scale).cdf(w_arr / L)) plt.plot(w_arr / L, eps * E, lw=4, color='red', ls='dashed', label='FB model') bundle = Reinforcement(r=0.13, tau=0.00001, V_f=0.9999, E_f=E, xi=RV('weibull_min', shape=shape, scale=scale), n_int=50) ccb = CompositeCrackBridge(E_m=25e3, reinforcement_lst=[bundle], Ll=L / 2., Lr=L / 2.) eps = [] for w in w_arr: ccb.w = w eps.append(ccb.max_norm_stress / E) plt.plot(w_arr / L, np.array(eps) * E, color='blue', lw=2, label='CB model') plt.legend(loc='best')
def showWeibull(): '''Utility function to show Weibull distributions''' t = frange(0, 2.5, 0.01) lambdaVal = 1 ks = [0.5, 1, 1.5, 5] for k in ks: wd = stats.weibull_min(k) plt.plot(t, wd.pdf(t), label='k = {0:.1f}'.format(k)) plt.xlim(0,2.5) plt.ylim(0,2.5) plt.xlabel('X') plt.ylabel('pdf(X)') plt.legend() outFile = 'Weibull_PDF.png' showData(outFile)
def give_cb_attr(self): #gives every crack bridge attributes no_of_fibers = norm(self.distr_of_fibers[0], self.distr_of_fibers[1]).ppf(np.random.rand(1)) phi_array = sin2x._ppf(np.random.rand(no_of_fibers)) le_array = (np.random.rand(no_of_fibers) * self.fiber_length / 2.) if self.with_tau_distr: tau_array = abs(weibull_min(self.weibull_tau_shape, self.weibull_tau_scale).ppf(np.random.rand(no_of_fibers))) else: tau_array = self.tau if self.with_f_distr: f_array = abs(norm(self.mean_f, self.stdev_f).ppf(np.random.rand(no_of_fibers))) else: f_array = self.f self.fiber_data_tuple[0].append(int(no_of_fibers)) self.fiber_data_tuple[1].append(phi_array) self.fiber_data_tuple[2].append(le_array) self.fiber_data_tuple[3].append(f_array) self.fiber_data_tuple[4].append(tau_array)
def weibull(scale=1,shape=1,loc=0): ''' pdf =shape* (x/scale+loc)**(shape-1) * exp(-(x/scale+loc)**shape) ''' return stats.weibull_min(shape,scale=scale,loc=-loc)
var_sim = [] var_eval = [] no_sim = linspace(100, 10000, 30) no_sim = [10000000] for points in no_sim: t = Test() t.sims = points X = t.X(x) N = t.N(x) sim = t.sims result = [] filaments = t.N_ppf(rand(sim)) for i, s in enumerate(filaments): resp = sum(t.X_ppf(rand(s - 1))) result.append(resp) mean_N = weibull_min(t.N_shape, scale=t.N_scale, loc=t.N_loc).stats("m") var_N = weibull_min(t.N_shape, scale=t.N_scale, loc=t.N_loc).stats("v") mean_X = weibull_min(t.X_shape, scale=t.X_scale, loc=t.X_loc).stats("m") var_X = weibull_min(t.X_shape, scale=t.X_scale, loc=t.X_loc).stats("v") var_D = mean_N * var_X + mean_X ** 2 * var_N var_sim.append(var(result)) var_eval.append(var_D) print var_sim print var_eval plt.plot(no_sim, var_sim) plt.plot(no_sim, var_eval) # print 'computed variance = ', var_D # print 'variance for', sim, 'simulated data =', var( result ) # plt.hist( result, normed = True, bins = 50 ) plt.show()
def _get_CDF( self ): sigma = linspace( 0, 30, 200 ) return sigma, weibull_min( self.m, scale = self.scale_sigma_m ).cdf( sigma )
def rvs(self, size): # This is working and matching the spreadsheet # But not sure why _min had to be used here... return ss.weibull_min(c=self.shape, loc=self.loc, scale=self.scale).rvs(size=size)
def _get_CDF_arr( self ): '''discretizes the CDF for equal spaced stress values''' return weibull_min( self.m, scale = self.scale_sigma_m ).cdf( self.Pf_sigma_arr )
def bundle_ld(): e = np.linspace(0.0, 1.5 * s, 1000) plt.plot(e, e * Ef * (1 - weibull_min(m, scale=s).cdf(e)), color="black", lw=3) plt.xlim(0, 1.6 * s)
def filaments_ld(): eps_fu = weibull_min(m, scale=s).ppf(np.linspace(0.001, 0.999, 50)) for eps in eps_fu: plt.plot([0, eps, eps], [0, eps * Ef, 0], color="grey") mu_eps = weibull_min(m, scale=s).stats("m") plt.plot([0, mu_eps, mu_eps], [0, mu_eps * Ef, 0], color="black", lw=3, ls="dashed")
def _get_Pf_sigma_arr( self ): '''equivalently discretizes the matrix stresses''' low = weibull_min( self.m, scale = self.scale_sigma_m ).ppf( 1e-10 ) high = weibull_min( self.m, scale = self.scale_sigma_m ).ppf( 1. - 1e-10 ) return linspace( low, high, self.n_cdf )
def surv_arr( self, sigma ): '''survival probabilities for stresses along the specimen''' return 1 - weibull_min( self.m, scale = self.scale_sigma_m ).cdf( sigma )