def scatter(x, y, label=None, title=None, x_lab=None, y_lab=None, add_trend_line=False, line_color='r', line_char=None, fig_size=(15, 7.5)): ''' Makes a bar chart from positions (pos) and heights. Use labels to replace pos elements. ''' plt.figure(figsize=(fig_size)) plt.scatter(x, y, label=label) if add_trend_line: m, b, r2, pv, std_error = linreg(x, y) lab = '' if line_char is not None: lab = _make_reglin_labels(r2, pv, std_error, line_char) else: lab = None plt.plot(x, m * x + b, '-', c=line_color, label=lab) if (label is not None) and (line_char is not None): plt.legend() if title is not None: plt.title(title) if y_lab is not None: plt.ylabel(y_lab) if x_lab is not None: plt.xlabel(x_lab) plt.show()
def __init__(self, asuid, species, length, exo, endo, total, N, mm, Sec): self.__asuid__ = asuid self.__species__ = species.lower() self.__length__ = float(length) self.__exo__ = float(exo) self.__endo__ = float(endo) self.__total__ = float(total) self.__N__ = array(N) self.__mm__ = array(mm) - min(mm) self.__Sec__ = array(Sec) - Sec[0] self.__sigmaN__ = self.__N__ / self.__total__ #P/A0 self.__epsilonN__ = (self.__mm__ / self.__length__) #dL/L0 self.__sigmaT__ = self.__sigmaN__ * (1 + self.__epsilonN__) #s(1+e) self.__epsilonT__ = ln(1 + self.__epsilonN__) #ln(1+e) self.__fmax__ = max(N) self.__uts__ = max(self.__sigmaN__) #evaluated from engineering stress self.__dmax__ = max(self.__mm__) self.__ufs__ = max( self.__epsilonN__) #evaluated from engineering strain self.__Eindex__ = [] lower = self.__ufs__ * 0 upper = self.__ufs__ * 0.33 self.__Eindex__.append( len([ x for x in takewhile(lambda x: x[1] <= lower, enumerate(self.__epsilonN__)) ])) self.__Eindex__.append( len([ y for y in takewhile(lambda y: y[1] <= upper, enumerate(self.__epsilonN__)) ])) xvals = self.__epsilonN__[self.__Eindex__[0]:self.__Eindex__[1]] yvals = self.__sigmaN__[self.__Eindex__[0]:self.__Eindex__[1]] self.__E__ = linreg( xvals, yvals) #engineering stress and strain via Hooke's Law self.__Etanl__ = self.__E__[0] t_upper = 0 t_lower = 0 for i in range(len(self.__epsilonN__) - 1): ub = self.__epsilonN__[i + 1] lb = self.__epsilonN__[i] uh = self.__sigmaN__[i + 1] lh = self.__sigmaN__[i] t_upper += (ub - lb) * uh t_lower += (ub - lb) * lh self.__U__ = (t_upper + t_lower) / 2
def recalcE(self, lower=0.00, upper=0.015, graphical=False, normal=False, limits='E_limits.txt'): self.__Eindex__ = [] if normal: eps = self.__epsilonT__ sig = self.__sigmaT__ else: eps = self.__epsilonN__ sig = self.__sigmaN__ if graphical: file = open(limits, 'r') for line in file: asuid, species, lims = line[:-1].split('|', 2) if asuid == self.__asuid__: x, y = lims.split(',') lowerg = float(x[1:]) upperg = float(y[:-1]) else: pass self.__Eindex__.append( len([ x for x in takewhile(lambda x: x[1] <= lowerg, enumerate(self.__Sec__)) ])) self.__Eindex__.append( len([ y for y in takewhile(lambda y: y[1] <= upperg, enumerate(self.__Sec__)) ])) else: self.__Eindex__ = [0, 1] low = False high = False while (not low) and (not high): for i, c in enumerate(self.__epsilonN__): if (c >= lower) and (not low): self.__Eindex__[0] = i low = True elif (c >= upper) and (not high): self.__Eindex__[1] = i high = True else: pass xvals = eps[self.__Eindex__[0]:self.__Eindex__[1]] yvals = sig[self.__Eindex__[0]:self.__Eindex__[1]] self.__E__ = linreg( xvals, yvals) #engineering stress and strain via Hooke's Law
def least_squares_plot(configs): """ This function is plotting a points with its errors on the 2D plane. :param configs: It is a dictionary containing the informations of: - Horizontal size of the plot * By default: "xsize": 16 - Vertical size of the plot * By default: "ysize": 9 - Symbol used to denote the point * By default: "symbol": 'x' - Name of input file * By default: "nameofinput": 'data.txt' - Name of y axis * By default: "nameofvalue": "$X$ value" - Name of x axis * By default: "nameofarg": "argument $x$" - Name of output file with extension * By default: "nameofoutput": '0' - If show legend: * By default: "showlegend": '0' """ arrofdata = np.loadtxt(configs['nameofinput']) x = arrofdata[:, 0] y = arrofdata[:, 1] a, b, r, _, da = linreg(x, y) a, b = a.round(), b.round() basex = np.linspace(min(x), max(x), 10000) pplt.figure(figsize=(configs['xsize'], configs['ysize'])) pplt.errorbar(x, y, yerr=da, marker=configs['symbol'], color=(200/255, 80/255, 80/255), label=configs['nameofvalue'], ls='') pplt.plot(basex, basex * a + b, label="regression line, a = {0}, b = {1}".format(a, b)) pplt.xlabel(configs['nameofarg']) pplt.ylabel(configs['nameofvalue']) pplt.tight_layout(0.1) if configs['showlegend'] != '0': leg = pplt.legend() leg.draggable() if configs['nameofoutput'] != '0': pplt.savefig(configs['nameofoutput']) else: pplt.show()
def xyplot(spec_set, save=True): spl = [] regx = [] regy = [] fig = plt.figure() ax = fig.add_subplot(111) #plt.ylim(0,0.04) #plt.xlim(0,8) xlab = 'test (units)' ylab = 'test (units)' ax.set_xlabel(xlab) ax.set_ylabel(ylab) ax.set_title('{}_vs_{}.pdf'.format(xlab, ylab)) car = mpatches.Patch(color='r', label='caryae') pro = mpatches.Patch(color='lightcoral', label='proboscideus') uni = mpatches.Patch(color='b', label='uniformis') hum = mpatches.Patch(color='skyblue', label='humeralis') sul = mpatches.Patch(color='dodgerblue', label='sulcatulus') vic = mpatches.Patch([], [], color='navy', label='victoriensis') ax.legend(handles=[car, pro, hum, sul, uni, vic], loc=4, fontsize=7) for spec in spec_set: new_l = spec.ufs() * 0.67 new_u = spec.ufs() * 1.00 spec.recalcE(lower=new_l, upper=new_u, graphical=False, normal=False) x = ln(spec.length()) y = ln(spec.Etanl()) #spec.uts() / spec.ufs() if spec.species() == 'caryae': ax.plot(x, y, color='r', marker='o') elif spec.species() == 'proboscideus': ax.plot(x, y, color='lightcoral', marker='o') elif spec.species() == 'uniformis': ax.plot(x, y, color='b', marker='o') elif spec.species() == 'humeralis': ax.plot(x, y, color='skyblue', marker='o') elif spec.species() == 'sulcatulus': ax.plot(x, y, color='dodgerblue', marker='o') elif spec.species() == 'victoriensis': ax.plot(x, y, color='navy', marker='o') else: pass regx.append(x) regy.append(y) spl.append( str(x) + ' ' + str(y) + ' ' + spec.asuid() + ' ' + spec.species()) x = array(regx) y = array(regy) regline = linreg(x, y) ax.plot(x, regline[0] * x + regline[1], color='black') ax.text( 0.03, 3, r'$y={:.3f}x+{:.3f}$'.format(regline[0], regline[1]) + '\n' + r'$R={:.3f}$'.format(regline[2]) + '\n' #+r'$p={:.3f}$'.format(regline[3]), + r'$p={0:s}$'.format(as_si(regline[3], 2)), fontsize=10) for i in sorted(spl): print(i) plt.show() if save: fig.savefig('plots/xyplots/{}_vs_{}.pdf'.format(xlab, ylab)) #plt.close() else: #plt.close() print('Plot not saved!!') print('m = {}'.format(regline[0]), 'b = {}'.format(regline[1]), 'r = {}'.format(regline[2]), 'p = {}'.format(regline[3]), 'std_err = {}'.format(regline[4]), sep='\n')
#Opens player running statistics lf_running = pd.read_csv( 'C:/Users/jmyou/Desktop/bb_data_project/Left_Hitter_run_Stats.csv') rf_running = pd.read_csv( 'C:/Users/jmyou/Desktop/bb_data_project/Right_Hitter_run_Stats.csv') s_running = pd.read_csv( 'C:/Users/jmyou/Desktop/bb_data_project/Switch_Hitter_run_Stats.csv') #Gets rid of NaN values, I did this so the following linear regressions would #make sense. lf_running = lf_running.dropna(axis=0) rf_running = rf_running.dropna(axis=0) s_running = s_running.dropna(axis=0) #Linear regressions for each group of batters l_reg = linreg(lf_running.loc[:, 'sprint_speed'], lf_running.loc[:, 'hp_to_1b']) r_reg = linreg(rf_running.loc[:, 'sprint_speed'], rf_running.loc[:, 'hp_to_1b']) s_reg = linreg(s_running.loc[:, 'sprint_speed'], s_running.loc[:, 'hp_to_1b']) #Best fit lines of each group of hitters x = np.array([i for i in range(20, 35)]) yr = r_reg[0] * x + r_reg[1] yl = l_reg[0] * x + l_reg[1] ys = s_reg[0] * x + s_reg[1] residual = yr - yl #Viridis Colors vir_v = (71 / 255, 33 / 255, 115 / 255) vir_b = (46 / 255, 111 / 255, 142 / 255)
def linfit(x, y): slope, intercept, rvalue, pvalue, stderr = linreg(np.log(x), np.log(y)) fit = (x**(slope) * np.exp(intercept)) return (fit, slope, intercept, rvalue, pvalue, stderr)