def printagraf(pontosx, pontosy, n, cor): plt.scatter(pontosx, pontosy, s=2, color=cor) #plt.plot(pontosx,pontosy,marker= 'o',label= 'Line 1') plt.xlabel('X ---------->') plt.ylabel('Y ---------->') if (n == 1): plt.title('Euler') elif (n == 2): plt.title('Euler Aprimorado') elif (n == 3): plt.title('Euler Inverso') elif (n == 4): plt.title('Runge Kutta') elif (n == 5): plt.title('Adams Bashford') elif (n == 6): plt.title('Adams Moulton') else: plt.title('Metodos Agrupados') plt.scatter(x, ey, s=2, color='black') plt.scatter(x, eay, s=2, color='red') plt.scatter(x, eiy, s=2, color='blue') plt.scatter(x, kf, s=2, color='orange') plt.scatter(x, aby, s=2, color='gray') plt.scatter(x, amy, s=2, color='green') plt.autoscale() plt.AutoLocator() plt.grid() plt.show()
def draw_plot(self, metrics, labels=None, ylabel=""): """ metrics: One or more metrics parameters. Each represents the history of one metric. """ metrics = metrics if isinstance(metrics, list) else [metrics] # Loop through metrics title = "" self.ax.yaxis.tick_right() self.ax.grid(which='both', axis='y') subax = self.ax.twinx() subax.set_yticks([]) for i, m in enumerate(metrics): label = labels[i] if labels else m.name # TODO: make a sortig by label, to let always right order in the # parenthesis. # TODO: use a standard formating function for values #title += (" " if title else "") + "{}: {}".format(label, m.data[-1]) p = self.ax.plot(m.formatted_steps, m.data, label=label) # add the tag to the last point. if m.data[-1] is not None: subax.set_yticks(list(subax.get_yticks())+[m.data[-1]]) subax.get_yticklabels()[-1].set_color(p[-1].get_color()) subax.set_ylim(self.ax.get_ylim()) self.ax.set_title(title) self.ax.set_ylabel(ylabel) self.ax.legend() self.ax.set_xlabel("Steps") self.ax.xaxis.set_major_locator(plt.AutoLocator())
def do_setting(ax, kind): setfn = getattr(ax, f"set_{kind}_locator") if maxn is not None: setfn(plt.MaxNLocator(maxn)) elif multiple is not None: setfn(plt.MultipleLocator(multiple)) else: setfn(plt.AutoLocator() if kind == "major" else AutoMinorLocator())
def plot_single(x, y, name, figsize=(20, 6)): fig, ax = plt.subplots(1, 1, figsize=figsize) g, = plt.plot(x, y, 'royalblue', label=name) ax.xaxis.set_major_locator(plt.AutoLocator()) ax.legend([g], [g.get_label()]) ax.set_ylabel(name.capitalize()) fig.autofmt_xdate() plt.title(name.capitalize(), fontsize=16) plt.show()
def minor_ticks(nx=5, ny=5, x=True, y=True): """ Sets *n* minor tick marks per major tick for the x and y axes of the current figure. *nx: integer number of minor ticks for x, DEFAULT: 5 *ny: integer number of minor ticks for y, DEFAULT: 5 *x: True/False, DEFAULT: True *y: True/False, DEFAULT: True """ ax = pyplot.gca() if x: ax.xaxis.set_major_locator(pyplot.AutoLocator()) x_major = ax.xaxis.get_majorticklocs() dx_minor = (x_major[-1] - x_major[0]) / (len(x_major) - 1) / nx ax.xaxis.set_minor_locator(pyplot.MultipleLocator(dx_minor)) if y: ax.yaxis.set_major_locator(pyplot.AutoLocator()) y_major = ax.yaxis.get_majorticklocs() dy_minor = (y_major[-1] - y_major[0]) / (len(y_major) - 1) / ny ax.yaxis.set_minor_locator(pyplot.MultipleLocator(dy_minor)) pyplot.plot() return
def draw_plot(self, metrics, labels=None, ylabel=""): """ metrics: One or more metrics parameters. Each represents the history of one metric. """ metrics = metrics if isinstance(metrics, list) else [metrics] # Loop through metrics title = "" for i, m in enumerate(metrics): label = labels[i] if labels else m.name # TODO: use a standard formating function for values title += (" " if title else "") + "{}: {}".format( label, m.data[-1]) self.ax.plot(m.formatted_steps, m.data, label=label) self.ax.set_title(title) self.ax.set_ylabel(ylabel) self.ax.legend() self.ax.set_xlabel("Steps") self.ax.xaxis.set_major_locator(plt.AutoLocator())
def plot_hist(returns, w, alpha=0.05, bins=50, height=6, width=10, ax=None): r""" Create a histogram of portfolio returns with the risk measures. Parameters ---------- returns : DataFrame Assets returns. w : DataFrame of shape (n_assets, 1) Portfolio weights. alpha : float, optional Significante level of VaR, CVaR and EVaR. The default is 0.05. bins : float, optional Number of bins of the histogram. The default is 50. height : float, optional Height of the image in inches. The default is 6. width : float, optional Width of the image in inches. The default is 10. ax : matplotlib axis, optional If provided, plot on this axis. The default is None. Raises ------ ValueError When the value cannot be calculated. Returns ------- ax : matplotlib axis. Returns the Axes object with the plot for further tweaking. Example ------- :: ax = plf.plot_hist(returns=Y, w=w1, alpha=0.05, bins=50, height=6, width=10, ax=None) .. image:: images/Histogram.png """ if not isinstance(returns, pd.DataFrame): raise ValueError("returns must be a DataFrame") if not isinstance(w, pd.DataFrame): raise ValueError("w must be a DataFrame") if w.shape[1] > 1 and w.shape[0] == 0: w = w.T elif w.shape[1] > 1 and w.shape[0] > 0: raise ValueError("w must be a DataFrame") if returns.shape[1] != w.shape[0]: a1 = str(returns.shape) a2 = str(w.shape) raise ValueError("shapes " + a1 + " and " + a2 + " not aligned") if ax is None: ax = plt.gca() fig = plt.gcf() fig.set_figwidth(width) fig.set_figheight(height) a = np.array(returns, ndmin=2) @ np.array(w, ndmin=2) ax.set_title("Portfolio Returns Histogram") n, bins1, patches = ax.hist(a, bins, density=1, edgecolor="skyblue", color="skyblue", alpha=0.5) mu = np.mean(a) sigma = np.std(a, axis=0, ddof=1).item() risk = [ mu, mu - sigma, mu - rk.MAD(a), -rk.VaR_Hist(a, alpha), -rk.CVaR_Hist(a, alpha), -rk.EVaR_Hist(a, alpha)[0], -rk.WR(a), ] label = [ "Mean: " + "{0:.2%}".format(risk[0]), "Mean - Std. Dev.(" + "{0:.2%}".format(-risk[1] + mu) + "): " + "{0:.2%}".format(risk[1]), "Mean - MAD(" + "{0:.2%}".format(-risk[2] + mu) + "): " + "{0:.2%}".format(risk[2]), "{0:.2%}".format( (1 - alpha)) + " Confidence VaR: " + "{0:.2%}".format(risk[3]), "{0:.2%}".format( (1 - alpha)) + " Confidence CVaR: " + "{0:.2%}".format(risk[4]), "{0:.2%}".format( (1 - alpha)) + " Confidence EVaR: " + "{0:.2%}".format(risk[5]), "Worst Realization: " + "{0:.2%}".format(risk[6]), ] color = [ "b", "r", "fuchsia", "darkorange", "limegreen", "dodgerblue", "darkgrey" ] for i, j, k in zip(risk, label, color): ax.axvline(x=i, color=k, linestyle="-", label=j) # add a 'best fit' line y = (1 / (np.sqrt(2 * np.pi) * sigma)) * np.exp(-0.5 * (1 / sigma * (bins1 - mu))**2) ax.plot( bins1, y, "--", color="orange", label="Normal: $\mu=" + "{0:.2%}".format(mu) + "$%, $\sigma=" + "{0:.2%}".format(sigma) + "$%", ) factor = (np.max(a) - np.min(a)) / bins ax.xaxis.set_major_locator(plt.AutoLocator()) ax.set_xticklabels(["{:3.2%}".format(x) for x in ax.get_xticks()]) ax.set_yticklabels(["{:3.2%}".format(x * factor) for x in ax.get_yticks()]) ax.legend(loc="upper right") # , fontsize = 'x-small') ax.grid(linestyle=":") ax.set_ylabel("Probability Density") fig = plt.gcf() fig.tight_layout() return ax
def plot_frontier( w_frontier, mu, cov=None, returns=None, rm="MV", rf=0, alpha=0.05, cmap="viridis", w=None, label="Portfolio", marker="*", s=16, c="r", height=6, width=10, t_factor=252, ax=None, ): r""" Creates a plot of the efficient frontier for a risk measure specified by the user. Parameters ---------- w_frontier : DataFrame Portfolio weights of some points in the efficient frontier. mu : DataFrame of shape (1, n_assets) Vector of expected returns, where n_assets is the number of assets. cov : DataFrame of shape (n_features, n_features) Covariance matrix, where n_features is the number of features. returns : DataFrame of shape (n_samples, n_features) Features matrix, where n_samples is the number of samples and n_features is the number of features. rm : str, optional The risk measure used to estimate the frontier. The default is 'MV'. Posible values are: - 'MV': Standard Deviation. - 'MAD': Mean Absolute Deviation. - 'MSV': Semi Standard Deviation. - 'FLPM': First Lower Partial Moment (Omega Ratio). - 'SLPM': Second Lower Partial Moment (Sortino Ratio). - 'CVaR': Conditional Value at Risk. - 'EVaR': Conditional Value at Risk. - 'WR': Worst Realization (Minimax) - 'MDD': Maximum Drawdown of uncompounded returns (Calmar Ratio). - 'ADD': Average Drawdown of uncompounded returns. - 'DaR': Drawdown at Risk of uncompounded returns. - 'CDaR': Conditional Drawdown at Risk of uncompounded returns. - 'UCI': Ulcer Index of uncompounded returns. rf : float, optional Risk free rate or minimum aceptable return. The default is 0. alpha : float, optional Significante level of VaR, CVaR, EVaR, DaR and CDaR. The default is 0.05. cmap : cmap, optional Colorscale, represente the risk adjusted return ratio. The default is 'viridis'. w : DataFrame of shape (n_assets, 1), optional A portfolio specified by the user. The default is None. label : str, optional Name of portfolio that appear on plot legend. The default is 'Portfolio'. marker : str, optional Marker of w. The default is "*". s : float, optional Size of marker. The default is 16. c : str, optional Color of marker. The default is 'r'. height : float, optional Height of the image in inches. The default is 6. width : float, optional Width of the image in inches. The default is 10. t_factor : float, optional Factor used to annualize expected return and expected risks for risk measures based on returns (not drawdowns). The default is 252. .. math:: \begin{align} \text{Annualized Return} & = \text{Return} \, \times \, \text{t_factor} \\ \text{Annualized Risk} & = \text{Risk} \, \times \, \sqrt{\text{t_factor}} \end{align} ax : matplotlib axis, optional If provided, plot on this axis. The default is None. Raises ------ ValueError When the value cannot be calculated. Returns ------- ax : matplotlib Axes Returns the Axes object with the plot for further tweaking. Example ------- :: label = 'Max Risk Adjusted Return Portfolio' mu = port.mu cov = port.cov returns = port.returns ax = plf.plot_frontier(w_frontier=ws, mu=mu, cov=cov, returns=returns, rm=rm, rf=0, alpha=0.05, cmap='viridis', w=w1, label=label, marker='*', s=16, c='r', height=6, width=10, t_factor=252, ax=None) .. image:: images/MSV_Frontier.png """ if not isinstance(w_frontier, pd.DataFrame): raise ValueError("w_frontier must be a DataFrame") if not isinstance(mu, pd.DataFrame): raise ValueError("mu must be a DataFrame") if not isinstance(cov, pd.DataFrame): raise ValueError("cov must be a DataFrame") if not isinstance(returns, pd.DataFrame): raise ValueError("returns must be a DataFrame") if returns.shape[1] != w_frontier.shape[0]: a1 = str(returns.shape) a2 = str(w_frontier.shape) raise ValueError("shapes " + a1 + " and " + a2 + " not aligned") if w is not None: if not isinstance(w, pd.DataFrame): raise ValueError("w must be a DataFrame") if w.shape[1] > 1 and w.shape[0] == 0: w = w.T elif w.shape[1] > 1 and w.shape[0] > 0: raise ValueError("w must be a column DataFrame") if returns.shape[1] != w.shape[0]: a1 = str(returns.shape) a2 = str(w.shape) raise ValueError("shapes " + a1 + " and " + a2 + " not aligned") if ax is None: ax = plt.gca() fig = plt.gcf() fig.set_figwidth(width) fig.set_figheight(height) mu_ = np.array(mu, ndmin=2) ax.set_ylabel("Expected Return") item = rmeasures.index(rm) x_label = rm_names[item] + " (" + rm + ")" ax.set_xlabel("Expected Risk - " + x_label) title = "Efficient Frontier Mean - " + x_label ax.set_title(title) X1 = [] Y1 = [] Z1 = [] for i in range(w_frontier.shape[1]): weights = np.array(w_frontier.iloc[:, i], ndmin=2).T risk = rk.Sharpe_Risk(weights, cov=cov, returns=returns, rm=rm, rf=rf, alpha=alpha) ret = mu_ @ weights ret = ret.item() * t_factor if rm not in ["MDD", "ADD", "CDaR", "UCI"]: risk = risk * t_factor**0.5 ratio = (ret - rf) / risk X1.append(risk) Y1.append(ret) Z1.append(ratio) ax1 = ax.scatter(X1, Y1, c=Z1, cmap=cmap) if w is not None: X2 = [] Y2 = [] for i in range(w.shape[1]): weights = np.array(w.iloc[:, i], ndmin=2).T risk = rk.Sharpe_Risk(weights, cov=cov, returns=returns, rm=rm, rf=rf, alpha=alpha) ret = mu_ @ weights ret = ret.item() * t_factor if rm not in ["MDD", "ADD", "CDaR", "UCI"]: risk = risk * t_factor**0.5 ratio = (ret - rf) / risk X2.append(risk) Y2.append(ret) ax.scatter(X2, Y2, marker=marker, s=s**2, c=c, label=label) ax.legend(loc="upper left") xmin = np.min(X1) - np.abs(np.max(X1) - np.min(X1)) * 0.1 xmax = np.max(X1) + np.abs(np.max(X1) - np.min(X1)) * 0.1 ymin = np.min(Y1) - np.abs(np.max(Y1) - np.min(Y1)) * 0.1 ymax = np.max(Y1) + np.abs(np.max(Y1) - np.min(Y1)) * 0.1 ax.set_ylim(ymin, ymax) ax.set_xlim(xmin, xmax) ax.xaxis.set_major_locator(plt.AutoLocator()) ax.set_yticklabels(["{:.4%}".format(x) for x in ax.get_yticks()]) ax.set_xticklabels(["{:.4%}".format(x) for x in ax.get_xticks()]) ax.tick_params(axis="y", direction="in") ax.tick_params(axis="x", direction="in") ax.grid(linestyle=":") colorbar = ax.figure.colorbar(ax1) colorbar.set_label("Risk Adjusted Return Ratio") fig = plt.gcf() fig.tight_layout() return ax
def plot_trace_file_3cols(nodes=None, trace=''): # nodes: only plot specified nodes' trace data (list) # trace: [CWND, RCWND, RTT] if not nodes: nodes = ['1', '2', '3', '4', '5', '6'] output_filename = trace + '.png' else: output_filename = '-'.join(['-'.join(nodes), trace + '.png']) for i in nodes: trace_filename = '-'.join([filename_base, i, 'TCP', trace + '.txt']) plot_style = 's' if trace == 'RCWND' else '-' x_vals, y_vals = [], [] with open(trace_filename, 'r') as f: for line in f: #time, old, new = re.match('([0-9\.]*)\W*([0-9\.]*)\W*([0-9\.]*)\W*') linedata = re.findall('([0-9\.]*)\W*', line) x_val, y_val = linedata[0], linedata[2] if trace == 'CWND' or trace == 'RCWND': # cwnd size to packets y_val = str(int(int(y_val) / int(packet_size))) if '.' in x_val: x_vals.append(float(x_val)) else: x_vals.append(int(x_val)) if '.' in y_val: y_vals.append(float(y_val)) else: y_vals.append(int(y_val)) plt.plot(x_vals, y_vals, colors[int(i) - 1] + plot_style, linewidth=0.5, antialiased=False, label='Node ' + i) #plt.plot(x_vals, y_vals, colors[int(i)-1], linestyle='s', markersize=2, linewidth=0.3, antialiased=False, label='Node '+i) plt.xlabel('time (s)') if trace == 'CWND' or trace == 'RCWND': plt.ylabel('CWND size (packets)') if trace == 'RTT': plt.ylabel('RTT (s)') #plt.axis('tight') if len(nodes) == 1: plt.title('Node {} {}'.format(nodes[0], trace)) elif len(nodes) == 6: plt.title('All nodes {}'.format(trace)) elif len(nodes) > 1: plt.title('Nodes {} {}'.format(', '.join(nodes), trace)) else: plt.title('Node 1-6 {}'.format(trace)) ax = plt.axes() #ax.xaxis.set_major_locator(plt.MaxNLocator(5)) #ax.yaxis.set_major_locator(plt.MaxNLocator(5)) ax.xaxis.set_major_locator(plt.AutoLocator()) ax.yaxis.set_major_locator(plt.AutoLocator()) ax.legend() #plt.show() plt.savefig('./png/' + output_filename, bbox_inches='tight')
def plotValue( self, xlabel=[], ylabel=[], pdpi=100, fill=True, fontsize=10, xsize=2.5, ysize=2, xlimits=[], lang='EN', TextRender=True, AxisNameLong=True, frame=False, nYTicks=2, nXTicks=5, xAxisRot=False, trans=1.0, font='tex gyre pagella', Units=[], plotBuffer=0.1, color=DefaultColor, delta=0.5, padLabel=[], ): plt.rcParams['font.family'] = font rcParams.update({'figure.autolayout': True}) rcParams.update(pgf_with_pdflatex) if not TextRender: rcParams.update({'svg.fonttype': 'none'}) if self.Form == 'interval' or self.nalpha == 1: # for interval plot xsize = 5 ysize = 0.25 fig = plt.figure(figsize=(xsize, ysize), dpi=pdpi) ax = fig.add_subplot(1, 1, 1) thick = 1**0.1 * 0.3 yplaces = [0.5 + i for i in reversed(range(1))] ax.set_yticks(yplaces) if not xlabel: xlabel = r'Uncertain value' if not ylabel: ylabel = r'Parameter' ax.set_yticklabels([ylabel], horizontalalignment='left') ax.set_ylim((0, 1)) start = self.Value[0, 0] end = self.Value[0, 1] pos = yplaces[0] ax.add_patch( patches.Rectangle((start, pos - delta / 2.0), end - start, thick, color=color)) pmin = np.min(self.Value) pmax = np.max(self.Value) ax.plot( (pmin * (1 - plotBuffer), pmax * (1 + plotBuffer)), (0, 0), 'w', alpha=0.0, ) sns.despine() nlmax = len(ylabel) yax = ax.get_yaxis() if not padLabel: padLabel = min(nlmax * 5.5, 175) yax.set_tick_params(direction='out', pad=padLabel) if not Units: ax.set_xlabel(xlabel) else: ax.set_xlabel(xlabel + ' [' + Units + ']') if xAxisRot: plt.setp(ax.get_xticklabels(), rotation='vertical') plt.xlim( (np.min(self.Value) - (np.max(self.Value) - np.min(self.Value)) / 5), (np.max(self.Value) + (np.max(self.Value) - np.min(self.Value)) / 5), ) else: fig = plt.figure(figsize=(xsize, ysize), dpi=pdpi) ax = fig.add_subplot(1, 1, 1) mu = np.linspace(1, 0, np.size(self.Value, 0)) xplot = np.concatenate( (np.flipud(self.Value[:, 0]), self.Value[:, 1]), axis=0) muplot = np.concatenate((np.flipud(mu), mu), axis=0) if fill: ax.fill_between( self.Value[:, 0], mu, facecolor=color, alpha=trans, linewidth=0.0, ) ax.fill_between( [self.Value[0, 1], self.Value[0, 0]], [1, 1], facecolor=color, alpha=trans, linewidth=0.0, ) ax.fill_between( self.Value[:, 1], mu, facecolor=color, alpha=trans, linewidth=0.0, ) ax.plot(xplot, muplot, 'k-', linewidth=1) plt.ylim(0, 1.10) if xlimits != []: plt.xlim(xlimits[0], xlimits[1]) plt.xlabel(xlabel) plt.yticks(np.arange(0, 1 + (nYTicks - 1), 1 / (nYTicks - 1))) xloc = plt.MaxNLocator(nXTicks) # plt.MaxNLocator(nXTicks) xloc = plt.AutoLocator() # xloc = plt.LinearLocator(numticks=nXTicks) ax.xaxis.set_major_locator(xloc) if not frame: ax.spines['right'].set_visible(False) ax.spines['top'].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() if xAxisRot: plt.setp(ax.get_xticklabels(), rotation='vertical') if AxisNameLong: if lang == 'EN': if TextRender: plt.ylabel(u'Membership $\\mu$') elif not TextRender: plt.ylabel(r'Membership \$\\mu\$') elif lang == 'DE': if TextRender: plt.ylabel(u'Zugehörigkeit $\\mu$') elif not TextRender: plt.ylabel(r'Zugeh\"origkeit \$\\mu\$') else: if TextRender: h = plt.ylabel(u'$\\mu$') elif not TextRender: h = plt.ylabel(r'\$\\mu\$') h.set_rotation(0) if xlabel == []: if lang == 'EN': plt.xlabel(r'Value') elif lang == 'DE': plt.xlabel(r'Wert') rcParams.update({'font.size': fontsize}) # plt.tight_layout() self.Plot = plt
#-------------------------------------------------------------- fig = Figure(figsize=(10, 6), facecolor='white') #-------------------------------------------------------------- axis = fig.add_subplot(111) axis.set_title("Graph plot of different vehicles and their count") t0, = axis.plot(time, car) t1, = axis.plot(time, bike) t2, = axis.plot(time, bus) t3, = axis.plot(time, cycle) t4, = axis.plot(time, truck) #axis.xticks(rotation=90) axis.set_ylabel('COUNT') axis.set_xlabel('TIME') #axis.set_xticklabels(time, rotation=90, ha='right') axis.xaxis.set_major_locator(plt.AutoLocator()) axis.grid() fig.legend((t0, t1, t2, t3, t4), ('CAR', 'BIKE', 'BUS', 'CYCLE', 'TRUCK'), 'upper right') #-------------------------------------------------------------- def _destroyWindow(): root.quit() root.destroy() #-------------------------------------------------------------- root = tk.Tk() root.withdraw() root.protocol('WM_DELETE_WINDOW', _destroyWindow)
def global_mayor_locator_auto(ax): ax.xaxis.set_major_locator(plt.AutoLocator()) ax.yaxis.set_major_locator(plt.AutoLocator())
def plot_trace_file(nodes=None, trace=''): # nodes: only plot specified nodes' trace data (list) # trace: [CWND, RCWND, RTT] figsize = tuple(map(lambda n: int(n), args.figsize.split(','))) figure = plt.figure(figsize=figsize) if not nodes: nodes = ['1', '2', '3', '4', '5', '6'] output_filename = trace + '.png' else: output_filename = '-'.join(['-'.join(nodes), trace + '.png']) if trace == 'MMWAVESINR': trace_filename = 'MmWaveSinrTime.txt' output_filename = 'MmWaveSinrTime.png' if trace == 'LTESINR': trace_filename = 'LteSinrTime.txt' output_filename = 'LteSinrTime.png' for i in nodes: if trace in ['CWND', 'RCWND', 'RTT', 'DATA']: trace_filename = '-'.join([filename_base, i, i, 'TCP', trace + '.txt']) plot_style = 's' if trace == 'RCWND' else '-' x_vals, y_vals = [], [] with open(trace_filename, 'r') as f: print("Opening ", trace_filename) for line in f: #time, old, new = re.match('([0-9\.]*)\W*([0-9\.]*)\W*([0-9\.]*)\W*') linedata = re.findall('([0-9\.]*)\W*', line) if trace == 'MMWAVESINR': if linedata[1] != str(i): # only gather current node's data continue x_val, y_val = linedata[0], linedata[value_to_plot(trace)] if trace == 'CWND' or trace == 'RCWND': # cwnd size to packets y_val = str(int(int(y_val) / int(packet_size))) if '.' in x_val: x_vals.append(float(x_val)) else: x_vals.append(int(x_val)) if '.' in y_val: y_vals.append(float(y_val)) else: y_vals.append(int(y_val)) if trace == 'DATA': (x_vals, y_vals) = data_trace(x_vals, y_vals) plt.plot(x_vals, y_vals, colors[int(i)-1]+plot_style, linewidth=0.5, antialiased=False, label='Flow '+i) #plt.plot(x_vals, y_vals, colors[int(i)-1], linestyle='s', markersize=2, linewidth=0.3, antialiased=False, label='Node '+i) plt.xlabel('time (s)') if trace == 'CWND' or trace == 'RCWND': plt.ylabel('CWND size (packets)') if trace == 'RTT': plt.ylabel('RTT (s)') if trace == 'DATA': plt.ylabel('Throughput (Mb/s)') if trace == 'MMWAVESINR': plt.ylabel('SINR (dB)') if trace == 'LTESINR': plt.ylabel('SINR') #plt.axis('tight') '''if len(nodes) == 1: plt.title('Node {} {}'.format(nodes[0], trace)) elif len(nodes) == 6: plt.title('All nodes {}'.format(trace)) elif len(nodes) > 1: plt.title('Nodes {} {}'.format(', '.join(nodes), trace)) else: plt.title('Node 1-6 {}'.format(trace)) if trace == 'DATA': plt.suptitle('Data throughput') plt.title('interval = ' + str(data_wndw) + ' s')''' ax = plt.axes() #ax.xaxis.set_major_locator(plt.MaxNLocator(5)) #ax.yaxis.set_major_locator(plt.MaxNLocator(5)) ax.xaxis.set_major_locator(plt.AutoLocator()) ax.yaxis.set_major_locator(plt.AutoLocator()) ax.legend() #plt.show() if not os.path.isdir('png'): os.makedirs('png') plt.savefig('./png/' + output_filename, bbox_inches='tight')