Ejemplo n.º 1
0
def plot_spectral_estimate(f, sdf, sdf_ests, limits=None, elabels=()):
    """
    Plot an estimate of a spectral transform against the ground truth.

    Utility file used in building the documentation
    """
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax_limits = (sdf.min() - 2*np.abs(sdf.min()),
                 sdf.max() + 1.25*np.abs(sdf.max()))
    ax.plot(f, sdf, 'c', label='True S(f)')

    if not elabels:
        elabels = ('',) * len(sdf_ests)
    colors = 'bgkmy'
    for e, l, c in zip(sdf_ests, elabels, colors):
        ax.plot(f, e, color=c, linewidth=2, label=l)

    if limits is not None:
        ax.fill_between(f, limits[0], y2=limits[1], color=(1, 0, 0, .3),
                        alpha=0.5)

    ax.set_ylim(ax_limits)
    ax.legend()
    return fig
Ejemplo n.º 2
0
def plot_spectral_estimate(f, sdf, sdf_ests, limits=None, elabels=()):
    """
    Plot an estimate of a spectral transform against the ground truth.

    Utility file used in building the documentation
    """
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax_limits = (sdf.min() - 2 * np.abs(sdf.min()),
                 sdf.max() + 1.25 * np.abs(sdf.max()))
    ax.plot(f, sdf, 'c', label='True S(f)')

    if not elabels:
        elabels = ('', ) * len(sdf_ests)
    colors = 'bgkmy'
    for e, l, c in zip(sdf_ests, elabels, colors):
        ax.plot(f, e, color=c, linewidth=2, label=l)

    if limits is not None:
        ax.fill_between(f,
                        limits[0],
                        y2=limits[1],
                        color=(1, 0, 0, .3),
                        alpha=0.5)

    ax.set_ylim(ax_limits)
    ax.legend()
    return fig
Ejemplo n.º 3
0
def HomeWinPercentGraph(teamname, HomeWin,ax):
    ax.plot(teamname,HomeWin)
    ax.set(title='Home Win %');
    plt.ylabel("Win %");
    plt.xlabel("Team");
    plt.ylim(0,100);
    ax.xaxis.set_label_coords(0.50, 0.075);
    plt.setp(ax.get_xticklabels(), rotation=30, horizontalalignment='right')
    plt.tick_params(axis='x', which='major', labelsize=7)
Ejemplo n.º 4
0
def plot_xcorr(xc, ij, fig=None, line_labels=None, xticks=None, yticks=None,
               xlabel=None, ylabel=None):
    """ Visualize the cross-correlation function"""

    if fig is None:
        fig = plt.figure()

    if not fig.get_axes():
        ax = fig.add_subplot(1, 1, 1)
    else:
        ax = fig.get_axes()[0]

    if line_labels is not None:
        #Reverse the order, so that pop() works:
        line_labels.reverse()
        this_labels = line_labels

    #Use the ij input as the labels:
    else:
        this_labels = [str(this) for this in ij].reverse()

    #Make sure that time displays on the x axis with the units you want:
    conv_fac = xc.time._conversion_factor
    this_time = xc.time / float(conv_fac)

    for (i, j) in ij:
        if this_labels is not None:
            #Use pop() to get the first one and remove it:
            ax.plot(this_time, xc.data[i, j].squeeze(),
                    label=this_labels.pop())
        else:
            ax.plot(this_time, xc.data[i, j].squeeze())

    ax.set_xlabel('Time(sec)')
    ax.set_ylabel('Correlation(normalized)')

    if xlabel is None:
        #Make sure that time displays on the x axis with the units you want:
        conv_fac = xc.time._conversion_factor
        time_label = xc.time / float(conv_fac)
        ax.set_xlabel('Time (%s)' % xc.time_unit)
    else:
        time_label = xlabel
        ax.set_xlabel(xlabel)

    if line_labels is not None:
        plt.legend()

    if ylabel is None:
        ax.set_ylabel('Correlation')
    else:
        ax.set_ylabel(ylabel)

    return fig
Ejemplo n.º 5
0
def plotRSI(startDate, endDate, cur, dp):
    plt.close()
    RSI = getRSI(startDate, endDate, cur, dp)
    xc2 = []
    for x in range(len(RSI)):
        xc2.append(70)

    xc1 = []
    for y in range(len(RSI)):
        xc1.append(30)
    fig, ax = plt.subplots()
    rsiLine = ax.plot(RSI.Date, RSI.RSI, label=str(dp) + ' Day RSI')
    upperLine = ax.plot(RSI.Date, xc2, '--', color='red')
    LowerLine = ax.plot(RSI.Date, xc1, '--', color='green')
    s1 = datetime.strptime(startDate, '%Y-%m-%d')
    plt.title('Resistance Strength Index', fontsize=20)
    plt.xlabel('Dates', fontsize=18)
    plt.ylabel('RSI', fontsize=18)
    plt.text(s1, 75, 'Overbought')
    plt.text(s1, 35, 'Oversold')
    plt.legend(loc='upper right')
    plt.show()
Ejemplo n.º 6
0
def animate(x):
    global runtime
    try:
        current_temp = float((get(APIURL + 'temp')).text)
    except:
        current_temp = 0
        print("Cannot reach API")
    if current_temp < 10:
        current_temp = 10
    if current_temp > 50:
        current_temp = 50
    print(temperature_history)
    temperature_history.insert(0,current_temp)
    time_ran.append(runtime)
    runtime += 1
    time_ran_plot = time_ran
    temperature_history_plot = temperature_history
    axis.clear()
    axis.plot(time_ran_plot, temperature_history_plot)
    axis.set_xlim(300,0)
    axis.set_ylim(10,50)
    plot.xlabel('seconds ago')
    plot.ylabel('degrees C')
Ejemplo n.º 7
0
        for u in arange(1,101):
            sum_Li2_A_dep[t] += (((A_dep[r]/(A_dep[r]+2.*z_y[t]**2 +2))**2)**u)/(u**2)
        yA_dep[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))*\
        (1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
 
#        yA_dep[t] = (sum_Li2_A_dep[t]*\
#        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
#        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

#    max_xA[r]= z_y[yA_dep.argmax()]
    
    # MAIN PLOT
    # ----------------------------------------------------------
    ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
    max_yA[r]= max(yA_dep)/yA_dep[0]	
    max_xA[r]= z_y[yA_dep.argmax()]
    ax.plot(max_xA, max_yA, linestyle = '', marker = 's', markerfacecolor='m')#,linestyle = lts[i],label=labels)#color = colors[j],

pl.xlabel(r'$\zeta/\omega_{0}$', size = 21)
pl.ylabel(r'$ \mathcal{\delta A}(i\zeta/\omega_{0} ) $', size = 21)
# INSET
# ----------------------------------------------------------
ax_inset = fig.add_axes([0.5,0.5,0.36,0.36])
#ax_inset = fig.add_axes([0.55,0.55,0.33,0.33])
# NB, if you change the above eqn for y, you must regenerate this input:
A_dep_r = linspace(0.0000000000001,10,300)#(0.000001,10,20)
#Ar = [A_dep_r,A_dep_r,A_dep_r,A_dep_r]
#r_dep = [r09,r10,r15,r20]
        #(1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
        Aiz = [y_dep * dee for y_dep, dee in zip(yA_dep_exp, de_e)]
#        yA_dep[t] = (sum_Li2_A_dep[t]*\
#        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
#        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

#    max_xA[r]= z_y[yA_dep.argmax()]

# MAIN PLOT
# ----------------------------------------------------------
#ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
#ax.plot(n/10.4,Aiz/Aiz[0],linestyle = ':',color = 'k')#,  color = colors[r], label = labels)
#ax.plot(n/ 11.0,Aiz,linestyle = ':',color = 'b')#,  color = colors[r], label = labels)
#ax.plot(n/(8.4*3.14/2),Aiz,linestyle = ':',color = 'g')#,  color = colors[r], label = labels)
#ax.plot(n/12.0,Aiz/Aiz[0],linestyle = ':',color = 'r')#,  color = colors[r], label = labels)
    ax.plot(n / 8.4, Aiz / Aiz[0], linestyle=':',
            color='y')  #,  color = colors[r], label = labels)

    #        yA_dep[t] = (sum_Li2_A_dep[t]*\
    #        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
    #        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

    #    max_xA[r]= z_y[yA_dep.argmax()]

    # MAIN PLOT
    # ----------------------------------------------------------
    #ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep/yA_dep[0])#,  color = colors[r], label = labels)
    ax.plot(z_y, yA_dep / yA_dep[0])  #,  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep)#/yA_dep[0])#,  color = colors[r], label = labels)

pl.xlabel(r'$\xi/\omega_{0}$', size=21)
Ejemplo n.º 9
0
def plot_corr_diff(tseries1, tseries2, fig=None,
                  ts_names=['1', '2']):
    """
    Show the differences in *Fischer-transformed* snr correlations for two
    time-series

    Parameters
    ----------
    tseries1, tseries2 : nitime TimeSeries objects
       These are the time-series to compare, with each of them having the
       dims: (n_channels, n_reps, time), where n_channels1 = n_channels2

    lb,ub: float
       Lower and upper bounds on the frequency range over which to
       calculate the information rate (default to [0,Nyquist]).

    fig: matplotlib figure object
       If you want to do this on already existing figure. Otherwise, a new
       figure object will be generated.

    ts_names: list of str
       Labels for the two inputs, to be used in plotting (defaults to
       ['1','2'])

    bandwidth, adaptive, low_bias: See :func:`SNRAnalyzer` for details


    Returns
    -------

    fig: a matplotlib figure object
    """

    if fig is None:
        fig = plt.figure()

    ax = fig.add_subplot(1, 1, 1)

    SNR1 = []
    SNR2 = []
    corr1 = []
    corr2 = []
    corr_e1 = []
    corr_e2 = []

    for i in range(tseries1.shape[0]):
        SNR1.append(nta.SNRAnalyzer(ts.TimeSeries(tseries1.data[i],
                                    sampling_rate=tseries1.sampling_rate)))

        corr1.append(np.arctanh(np.abs(SNR1[-1].correlation[0])))
        corr_e1.append(SNR1[-1].correlation[1])

        SNR2.append(nta.SNRAnalyzer(ts.TimeSeries(tseries2.data[i],
                                    sampling_rate=tseries2.sampling_rate)))

        corr2.append(np.arctanh(np.abs(SNR2[-1].correlation[0])))
        corr_e2.append(SNR1[-1].correlation[1])

    ax.scatter(np.array(corr1), np.array(corr2))
    ax.errorbar(np.mean(corr1), np.mean(corr2),
                 yerr=np.std(corr2),
                 xerr=np.std(corr1))
    plot_min = min(min(corr1), min(corr2))
    plot_max = max(max(corr1), max(corr2))
    ax.plot([plot_min, plot_max], [plot_min, plot_max], 'k--')
    ax.set_xlabel('Correlation (Fischer Z) %s' % ts_names[0])
    ax.set_ylabel('Correlation (Fischer Z) %s' % ts_names[1])

    return fig, corr1, corr2
Ejemplo n.º 10
0
def plotTSs1(start_date, end_date, shortMa, longMa):
    yf.pdr_override()
    plt.close()
    shortMaP = int(shortMa)
    longMaP = int(longMa)

    data = pdr.get_data_yahoo("BTC-USD", start_date, end_date)
    btc = pd.DataFrame(data)

    btc = btc[['Adj Close']]
    btc.columns = ['price']
    btc.reset_index(level=0, inplace=True)

    ###################################################################################

    # Code taken from Willems, K., 2019. (Tutorial) Python For Finance: Algorithmic Trading
    #[online] DataCamp Community. Available at: <https://www.datacamp.com/community/tutorials/finance-python-trading#basics>

    plt.close()

    signal = pd.DataFrame(index=btc.index)  #copy index from BTC

    signal['id'] = 0.0

    signal['shortMA'] = btc['price'].rolling(
        window=shortMaP,
        min_periods=1).mean()  #Short Moving Average Calculated

    signal['longMA'] = btc['price'].rolling(
        window=longMaP, min_periods=1).mean()  ##Long Moving Average Calculated

    signal['id'][shortMaP:] = np.where(
        signal['shortMA'][shortMaP:] > signal['longMA'][shortMaP:], 1.0,
        0.0)  #where short moving average surpasses long, id is changed to 1

    #[shortMaP:] only for the period that is surpasses than the short moving average

    signal['buySell'] = signal['id'].diff()

    fig = plt.figure()

    ax1 = fig.add_subplot(111, ylabel=' Currency Price in $')

    ax1.plot(btc.price)  #Plot price
    # Plot the short and long moving averages
    ax1.plot(signal['shortMA'], color='black', label='Short Moving Average')
    ax1.plot(signal['longMA'], color='orange', label='Long Moving Average')
    ax1.legend(loc='upper right')

    # The buy signals according to buySell are plotted
    ax1.plot(signal.loc[signal.buySell == 1.0].index,
             signal.shortMA[signal.buySell == 1.0],
             '^',
             markersize=10,
             color='green')

    # The sell signals according to buySell are plotted
    ax1.plot(signal.loc[signal.buySell == -1.0].index,
             signal.shortMA[signal.buySell == -1.0],
             'v',
             markersize=10,
             color='red')

    # Show the plot
    plt.show()

    ###################################################################################
    # Code taken from Willems, K., 2019. (Tutorial) Python For Finance: Algorithmic Trading

    portfolio = pd.DataFrame(index=signal.index)

    initInvestment = 100000
    stocksOwned = pd.DataFrame(index=signal.index).fillna(0.0)

    noCur = 10  #No of currency to be purchased

    stocksOwned['BTC'] = noCur * signal['id']

    portfolio['Holdings'] = stocksOwned['BTC'].multiply(btc['price'], axis=0)

    buySell = stocksOwned['BTC'].diff()

    portfolio['cash'] = initInvestment - (buySell.multiply(btc['price'],
                                                           axis=0)).cumsum()

    portfolio['total'] = portfolio['cash'] + portfolio['Holdings']

    portfolio['cash'][0] = initInvestment
    portfolio['total'][0] = initInvestment

    ###################################################################################

    fig = plt.figure()
    ax = fig.add_subplot(111)

    ax.plot(portfolio.index, portfolio['total'], label='Price')
    ax.set_xlabel('Date')
    ax.set_ylabel('Value of Portfolio in $')

    day = portfolio.loc[signal.buySell == 1.0].index
    day2 = portfolio.loc[signal.buySell == -1.0].index

    #x co
    ax.scatter(x=day, y=portfolio.loc[day, 'total'], color='green', marker='^')
    ax.scatter(x=day2, y=portfolio.loc[day2, 'total'], color='red', marker='^')
Ejemplo n.º 11
0
#ax.plot(n/(8.4*3.14/2),Aiz,linestyle = ':',color = 'g')#,  color = colors[r], label = labels)
#    ax.plot(n/12.0,Aiz,linestyle = ':',color = 'r')#,  color = colors[r], label = labels)
#ax.plot(n/12.,Aiz,linestyle = ':',color = 'y')#,  color = colors[r], label = labels)
    total = trapz(yA_dep / yA_dep[0], z_y)
    #print total
    #        yA_dep[t] = (sum_Li2_A_dep[t]*\
    #        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
    #        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

    #    max_xA[r]= z_y[yA_dep.argmax()]
    #pl.plot(A_dep,total)
    # MAIN PLOT
    # ----------------------------------------------------------
    #ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep/yA_dep[0])#,  color = colors[r], label = labels)
    ax.plot(z_y, yA_dep / yA_dep[0])  #,  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep)#/yA_dep[0])#,  color = colors[r], label = labels)

pl.xlabel(r'$\xi/\omega_{0}$', size=21)
pl.ylabel(r'$ A(\xi/\omega_{0} ) $', size=21)

totals = [
    0.0, 0.844235588588, 0.902052850418, 0.959171922439, 1.01581508011,
    1.07214213658, 1.12827223495, 1.18429669819, 1.24028706962, 1.2963003875,
    1.35238278039, 1.40857199673, 1.46489923268, 1.52139048298, 1.57806755879,
    1.63494886788, 1.69205002126, 1.74938431132, 1.80696309288, 1.86479609019,
    1.92289164646, 1.98125692852, 2.03989809587, 2.09882044138, 2.1580285091,
    2.21752619349, 2.2773168235, 2.33740323411, 2.39778782755, 2.45847262587,
    2.51945931629, 2.58074929044, 2.6423436785, 2.70424337889, 2.76644908432,
    2.82896130457, 2.89178038653, 2.95490653189, 3.01833981278, 3.08208018557,
    3.14612750322, 3.21048152616, 3.27514193206, 3.3401083245, 3.40538024081,
Ejemplo n.º 12
0
def plot_corr_diff(tseries1, tseries2, fig=None, ts_names=['1', '2']):
    """
    Show the differences in *Fischer-transformed* snr correlations for two
    time-series

    Parameters
    ----------
    tseries1, tseries2 : nitime TimeSeries objects
       These are the time-series to compare, with each of them having the
       dims: (n_channels, n_reps, time), where n_channels1 = n_channels2

    lb,ub: float
       Lower and upper bounds on the frequency range over which to
       calculate the information rate (default to [0,Nyquist]).

    fig: matplotlib figure object
       If you want to do this on already existing figure. Otherwise, a new
       figure object will be generated.

    ts_names: list of str
       Labels for the two inputs, to be used in plotting (defaults to
       ['1','2'])

    bandwidth, adaptive, low_bias: See :func:`SNRAnalyzer` for details


    Returns
    -------

    fig: a matplotlib figure object
    """

    if fig is None:
        fig = plt.figure()

    ax = fig.add_subplot(1, 1, 1)

    SNR1 = []
    SNR2 = []
    corr1 = []
    corr2 = []
    corr_e1 = []
    corr_e2 = []

    for i in range(tseries1.shape[0]):
        SNR1.append(
            nta.SNRAnalyzer(
                ts.TimeSeries(tseries1.data[i],
                              sampling_rate=tseries1.sampling_rate)))

        corr1.append(np.arctanh(np.abs(SNR1[-1].correlation[0])))
        corr_e1.append(SNR1[-1].correlation[1])

        SNR2.append(
            nta.SNRAnalyzer(
                ts.TimeSeries(tseries2.data[i],
                              sampling_rate=tseries2.sampling_rate)))

        corr2.append(np.arctanh(np.abs(SNR2[-1].correlation[0])))
        corr_e2.append(SNR1[-1].correlation[1])

    ax.scatter(np.array(corr1), np.array(corr2))
    ax.errorbar(np.mean(corr1),
                np.mean(corr2),
                yerr=np.std(corr2),
                xerr=np.std(corr1))
    plot_min = min(min(corr1), min(corr2))
    plot_max = max(max(corr1), max(corr2))
    ax.plot([plot_min, plot_max], [plot_min, plot_max], 'k--')
    ax.set_xlabel('Correlation (Fischer Z) %s' % ts_names[0])
    ax.set_ylabel('Correlation (Fischer Z) %s' % ts_names[1])

    return fig, corr1, corr2
        #(1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
	Aiz = [y_dep*dee for y_dep,dee in zip(yA_dep_exp,de_e)]
#        yA_dep[t] = (sum_Li2_A_dep[t]*\
#        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
#        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

#    max_xA[r]= z_y[yA_dep.argmax()]
    
    # MAIN PLOT
    # ----------------------------------------------------------
    #ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
    #ax.plot(n/10.4,Aiz/Aiz[0],linestyle = ':',color = 'k')#,  color = colors[r], label = labels)
    #ax.plot(n/ 11.0,Aiz,linestyle = ':',color = 'b')#,  color = colors[r], label = labels)
    #ax.plot(n/(8.4*3.14/2),Aiz,linestyle = ':',color = 'g')#,  color = colors[r], label = labels)
    #ax.plot(n/12.0,Aiz/Aiz[0],linestyle = ':',color = 'r')#,  color = colors[r], label = labels)
    ax.plot(n/8.4,Aiz/Aiz[0],linestyle = ':',color = 'y')#,  color = colors[r], label = labels)

#        yA_dep[t] = (sum_Li2_A_dep[t]*\
#        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
#        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

#    max_xA[r]= z_y[yA_dep.argmax()]
    
    # MAIN PLOT
    # ----------------------------------------------------------
    #ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep/yA_dep[0])#,  color = colors[r], label = labels)
    ax.plot(z_y,yA_dep/yA_dep[0])#,  color = colors[r], label = labels)
    #ax.plot(z_y,yA_dep)#/yA_dep[0])#,  color = colors[r], label = labels)

Ejemplo n.º 14
0
def plotTsS2(start_date, end_date):

    plt.close()
    yf.pdr_override()

    data = pdr.get_data_yahoo("BTC-USD", start_date, end_date)
    btc = pd.DataFrame(data)

    btc = btc[['Adj Close']]
    btc.columns = ['Close']
    btc.reset_index(level=0, inplace=True)

    b = pd.DataFrame()

    for x in btc:
        b['price'] = btc['Close']
        b['sma'] = btc['Close'].rolling(window=20).mean()
        b['std'] = btc['Close'].rolling(window=20).std()

        b['bolU'] = b['sma'] + (2 * b['std'])  #Calculating Upper Bound
        b['bolD'] = b['sma'] - (2 * b['std'])  #Calculating Lower Bound
        #Convert Bollinger Bands to %b - bollinger column
        b['bollinger'] = (b['price'] - b['bolD']) / (b['bolU'] - b['bolD'])

    bb1 = b[['price', 'bolU', 'bolD', 'bollinger']]
    bb1.columns = ['Price', 'Upper Band', 'Lower Band', 'Bollinger']
    bb1.fillna(0, inplace=True)

    # In[ ]:

    # In[9]:

    RSI = pd.DataFrame(index=btc.index)

    RSI['price'] = btc['Close']

    RSI['val'] = None
    RSI['up'] = 0  #When there is no up  value 0
    RSI['down'] = 0  #When there is no down   value 0

    size = RSI.shape[0]
    dp = 14

    for x in range(size):
        if x == 0:
            continue  #first day will continue
        #calculating the ups , when closing price is higher in day x than x -1
        if RSI['price'].iloc[x] > RSI['price'].iloc[x - 1]:  #
            RSI['up'].iloc[x] = RSI['price'].iloc[x] - RSI['price'].iloc[x - 1]
        else:
            #calculating the downs days , when closing price is lower in day x than x -1
            RSI['down'].iloc[x] = RSI['price'].iloc[x -
                                                    1] - RSI['price'].iloc[x]

        if x >= dp:
            avgUp = RSI['up'][x - dp:x].sum(
            ) / dp  #calculates avg up of last dp days
            avgDown = RSI['down'][x - dp:x].sum(
            ) / dp  #calculates avg down of last dp days
            rs = avgUp / avgDown  #calculation of RS
            RSI['val'].iloc[x] = 100 - 100 / (1 + rs)

    signals = pd.DataFrame(index=btc.index)  #copy index for BTC

    signals['price'] = btc['Close']
    signals['id'] = 0.0

    signals['RSI'] = RSI['val']
    signals['RSI'].fillna(0, inplace=True)

    signals['bollinger'] = bb1['Bollinger']

    signals['id'] = [np.nan for i in signals.index]

    # only  verifications for days after DPth (period of RSI) day
    signals['id'][dp:].loc[((signals['RSI'] < 30) &
                            (signals['bollinger'] < 0))] = 1
    signals['id'][dp:].loc[((signals['RSI'] > 70) &
                            (signals['bollinger'] > 1))] = 0
    signals['id'].ffill(inplace=True)  #fill empty values with 0
    signals['id'].fillna(0, inplace=True)

    signals['buySell'] = signals['id'].diff()
    signals['buySell'].fillna(0, inplace=True)

    fig, (ax) = plt.subplots(1, 1)

    ax.plot(signals['price'])
    ax.set_xlabel('Date')
    ax.set_ylabel('Value in $')
    day = signals.loc[signals.buySell == 1.0].index
    day2 = signals.loc[signals.buySell == -1.0].index

    #x cordinates, index of day    --> y cordinate,price of day index
    ax.scatter(
        x=day,
        y=signals.loc[day, 'price'],
        marker='^',
        color='green',
    )
    ax.scatter(x=day2, y=signals.loc[day2, 'price'], marker='v', color='red')

    plt.show()
Ejemplo n.º 15
0
def plotPorts2(start_date, end_date):
    plt.close()
    yf.pdr_override()

    data = pdr.get_data_yahoo("BTC-USD", start_date, end_date)
    btc = pd.DataFrame(data)

    btc = btc[['Adj Close']]
    btc.columns = ['Close']
    btc.reset_index(level=0, inplace=True)

    # In[8]:

    b = pd.DataFrame()

    for x in btc:
        b['price'] = btc['Close']
        b['sma'] = btc['Close'].rolling(window=20).mean()
        b['std'] = btc['Close'].rolling(window=20).std()

        b['bolU'] = b['sma'] + (2 * b['std'])  #Calculating Upper Bound
        b['bolD'] = b['sma'] - (2 * b['std'])  #Calculating Lower Bound
        #Convert Bollinger Bands to %b - bollinger column
        b['bollinger'] = (b['price'] - b['bolD']) / (b['bolU'] - b['bolD'])

    bb1 = b[['price', 'bolU', 'bolD', 'bollinger']]
    bb1.columns = ['Price', 'Upper Band', 'Lower Band', 'Bollinger']
    bb1.fillna(0, inplace=True)

    # In[ ]:

    # In[9]:

    RSI = pd.DataFrame(index=btc.index)

    RSI['price'] = btc['Close']

    RSI['val'] = None
    RSI['up'] = 0  #When there is no up  value 0
    RSI['down'] = 0  #When there is no down   value 0

    size = RSI.shape[0]
    dp = 14

    for x in range(size):
        if x == 0:
            continue  #first day will continue
        #calculating the ups , when closing price is higher in day x than x -1
        if RSI['price'].iloc[x] > RSI['price'].iloc[x - 1]:  #
            RSI['up'].iloc[x] = RSI['price'].iloc[x] - RSI['price'].iloc[x - 1]
        else:
            #calculating the downs days , when closing price is lower in day x than x -1
            RSI['down'].iloc[x] = RSI['price'].iloc[x -
                                                    1] - RSI['price'].iloc[x]

        if x >= dp:
            avgUp = RSI['up'][x - dp:x].sum(
            ) / dp  #calculates avg up of last dp days
            avgDown = RSI['down'][x - dp:x].sum(
            ) / dp  #calculates avg down of last dp days
            rs = avgUp / avgDown  #calculation of RS
            RSI['val'].iloc[x] = 100 - 100 / (1 + rs)

    signals = pd.DataFrame(index=btc.index)  #copy index for BTC

    signals['price'] = btc['Close']
    signals['id'] = 0.0

    signals['RSI'] = RSI['val']
    signals['RSI'].fillna(0, inplace=True)

    signals['bollinger'] = bb1['Bollinger']

    signals['id'] = [np.nan for i in signals.index]

    # only  verifications for days after DPth (period of RSI) day
    signals['id'][dp:].loc[((signals['RSI'] < 30) &
                            (signals['bollinger'] < 0))] = 1
    signals['id'][dp:].loc[((signals['RSI'] > 70) &
                            (signals['bollinger'] > 1))] = 0
    signals['id'].ffill(inplace=True)  #fill empty values with 0
    signals['id'].fillna(0, inplace=True)

    signals['buySell'] = signals['id'].diff()
    signals['buySell'].fillna(0, inplace=True)

    ###################################################################################
    # Code taken from Willems, K., 2019. (Tutorial) Python For Finance: Algorithmic Trading

    initInvestment = 100000
    stocksOwned = pd.DataFrame(index=signals.index).fillna(0.0)

    noCur = 10  #No of currency to be purchased

    stocksOwned['BTC'] = noCur * signals['id']

    portfolio = pd.DataFrame(index=signals.index)
    portfolio['Holdings'] = stocksOwned['BTC'].multiply(btc['Close'], axis=0)

    buySell = stocksOwned['BTC'].diff()

    portfolio['cash'] = initInvestment - (buySell.multiply(btc['Close'],
                                                           axis=0)).cumsum()

    portfolio['total'] = portfolio['cash'] + portfolio['Holdings']

    portfolio['cash'][0] = initInvestment
    portfolio['total'][0] = initInvestment

    ###################################################################################

    # In[50]:

    fig, (ax) = plt.subplots(1, 1, sharex=True)

    ax.plot(portfolio.index, portfolio['total'], label='Price')
    ax.set_xlabel('Date')
    ax.set_ylabel('Value of portfolio in USD')
    day = signals.loc[signals.buySell == 1.0].index
    day2 = signals.loc[signals.buySell == -1.0].index

    ax.scatter(x=day, y=portfolio.loc[day, 'total'], color='green')
    ax.scatter(x=day2, y=portfolio.loc[day2, 'total'], color='red')

    plt.show()
Ejemplo n.º 16
0
        for u in arange(1,101):
            sum_Li2_A_dep[t] += (((A_dep[r]/(A_dep[r]+2.*z_y[t]**2 +2))**2)**u)/(u**2)
        yA_dep[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))*\
        (1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
 
#        yA_dep[t] = (sum_Li2_A_dep[t]*\
#        (A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**(-1)*\
#        (1-(A_dep[r]/(A_dep[r]+2.*z_y[t]**2+2))**2))\

#    max_xA[r]= z_y[yA_dep.argmax()]
    
    # MAIN PLOT
    # ----------------------------------------------------------
    ax.plot(z_y,yA_dep/yA_dep[0],  color = colors[r], label = labels)

pl.xlabel(r'$\frac{\xi}{\omega_{0}}$', size = 'x-large')
pl.ylabel(r'$ y (\frac{\xi}{\omega_{0}} ) $', size = 'x-large')
# INSET
# ----------------------------------------------------------
ax_inset = fig.add_axes([0.55,0.55,0.33,0.33])
# NB, if you change the above eqn for y, you must regenerate this input:
ax_inset.plot(x_ymax,y_ymax, color = 'k', linestyle = '-')
pl.xlabel(r'$A\,=\,\frac{2}{\pi}C$',size = 'small')
pl.ylabel(r'MAX$[y(\frac{\xi}{\omega_{0}})] $',size = 'small')
pl.tick_params(labelsize = 'small')
#ax.legend(loc = 'best')
pp.savefig()
pl.show()
pl.close()        
#pl.figure()
#pl.plot(z_y,yA/yA[0], color = 'b', label = 'A = 1.0')
#pl.plot(z_y,yB/yB[0], color = 'g', label = 'B = 4.0')
#pl.plot(z_y,yC/yC[0], color = 'r', label = 'C = 6.0')
#pl.title(r'Function $y(\xi)$ from $eqn\,6$')
#pl.tick_params(labelsize = 'small')
#pl.xlabel(r'$0<\frac{\xi}{\omega_0}<2$', size = 'x-large')
#pl.ylabel(r'$y(\xi)$', size = 'x-large')# \mathrm{ F}\,\, \frac{ 8 \pi D^{2} }{k_{B} T}$')
#pl.legend(loc = 'best')
#pl.axis([0.0, 2.2,0.0,1.2])
#pp.savefig()
#pl.show()
##############################################################
fig = pl.figure()
ax = fig.add_axes([0.1,0.1,0.8,0.8])
ax.plot(x_peak  , y_peak,   color = 'g',label = r'Synthesized')# $\epsilon$"($\omega$)', linestyle='-')
ax.plot(x_nopeak, y_nopeak, color = 'b',label = r'Ab initio')# $\epsilon$"($\omega$)',   linestyle='-')
#ax.legend(loc = 'best')
#pl.title(r'$\epsilon$"($\omega$)  Ab Initio and Synthisized')
pl.xlabel(r'$\omega$', size = 22)
pl.ylabel(r'$\epsilon$"($\omega$)', size = 21)

ax_inset = fig.add_axes([0.53,0.50,0.36,0.36])
ax_inset.plot(x_nopeak,diff_eps,color='r',label=r'$\epsilon$"($\omega)_{synthesized}$-$\epsilon$"($\omega)_{ab\,initio}$')
ax_inset.plot(x_nopeak,listofzeros,color = 'k', label=r'$\delta$$\epsilon$"($\omega$) = 0')
#pl.title(r'Difference $\epsilon$"($\omega$)', size = 'small')
pl.tick_params(labelsize = 'small')
pl.xlabel(r'$\omega$', size = 14)
pl.ylabel(r'$\delta$$\epsilon$"($\omega$)', size = 14)
#pp.savefig()
#pl.savefig('130807_plots/fig2a_eps2_deps2.pdf')
Ejemplo n.º 18
0
def plot_xcorr(xc,
               ij,
               fig=None,
               line_labels=None,
               xticks=None,
               yticks=None,
               xlabel=None,
               ylabel=None):
    """ Visualize the cross-correlation function"""

    if fig is None:
        fig = plt.figure()

    if not fig.get_axes():
        ax = fig.add_subplot(1, 1, 1)
    else:
        ax = fig.get_axes()[0]

    if line_labels is not None:
        #Reverse the order, so that pop() works:
        line_labels.reverse()
        this_labels = line_labels

    #Use the ij input as the labels:
    else:
        this_labels = [str(this) for this in ij].reverse()

    #Make sure that time displays on the x axis with the units you want:
    conv_fac = xc.time._conversion_factor
    this_time = xc.time / float(conv_fac)

    for (i, j) in ij:
        if this_labels is not None:
            #Use pop() to get the first one and remove it:
            ax.plot(this_time,
                    xc.data[i, j].squeeze(),
                    label=this_labels.pop())
        else:
            ax.plot(this_time, xc.data[i, j].squeeze())

    ax.set_xlabel('Time(sec)')
    ax.set_ylabel('Correlation(normalized)')

    if xlabel is None:
        #Make sure that time displays on the x axis with the units you want:
        conv_fac = xc.time._conversion_factor
        time_label = xc.time / float(conv_fac)
        ax.set_xlabel('Time (%s)' % xc.time_unit)
    else:
        time_label = xlabel
        ax.set_xlabel(xlabel)

    if line_labels is not None:
        plt.legend()

    if ylabel is None:
        ax.set_ylabel('Correlation')
    else:
        ax.set_ylabel(ylabel)

    return fig
ax = fig.add_axes([0.1,0.1,0.8,0.8])
colors = ['b','g','r','c','m','y','k']
for r in range(len(A_dep)):
    labels=r'$A\, =\, %.2f$' % A_dep[r]
    for t in range(len(z_y)):
        sum_Li2_A_dep[t] = 0.0
        for u in arange(1,101):
            sum_Li2_A_dep[t] += (((A_dep[r]/(A_dep[r]+2.*z_y[t]**2 +2))**2)**u)/(u**2)
        yA_dep[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))*\
        (1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))

        yA_dep_exp[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))#*\
        #(1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
	Aiz = [2.0*y_dep*dee for y_dep,dee in zip(yA_dep_exp,de_e)]
    ax.plot(n/12.,Aiz,linestyle = ':',color = 'y')#,  color = colors[r], label = labels)
    total = trapz(yA_dep,z_y)
    print total
    ax.plot(z_y,yA_dep)#,  color = colors[r], label = labels)
pl.xlabel(r'$\xi/\omega_{0}$', size = 21)
pl.ylabel(r'$ A(\xi/\omega_{0} ) $', size = 21)


pl.show()
pl.close()        


Ejemplo n.º 20
0
def plot_tseries(time_series,
                 fig=None,
                 axis=0,
                 xticks=None,
                 xunits=None,
                 yticks=None,
                 yunits=None,
                 xlabel=None,
                 ylabel=None,
                 yerror=None,
                 error_alpha=0.1,
                 time_unit=None,
                 **kwargs):
    """plot a timeseries object

    Arguments
    ---------

    time_series: a nitime time-series object

    fig: a figure handle, opens a new figure if None

    subplot: an axis number (if there are several in the figure to be opened),
        defaults to 0.

    xticks: optional, list, specificies what values to put xticks on. Defaults
    to the matlplotlib-generated.

    yticks: optional, list, specificies what values to put xticks on. Defaults
    to the matlplotlib-generated.

    xlabel: optional, list, specificies what labels to put on xticks

    ylabel: optional, list, specificies what labels to put on yticks

    yerror: optional, UniformTimeSeries with the same sampling_rate and number
    of samples and channels as time_series, the error will be displayed as a
    shading above and below the plotted time-series

    """

    if fig is None:
        fig = plt.figure()

    if not fig.get_axes():
        ax = fig.add_subplot(1, 1, 1)
    else:
        ax = fig.get_axes()[axis]

    #Make sure that time displays on the x axis with the units you want:
    #If you want to change the time-unit on the visualization from that used to
    #represent the time-series:
    if time_unit is not None:
        tu = time_unit
        conv_fac = ts.time_unit_conversion[time_unit]
    #Otherwise, get the information from your input:
    else:
        tu = time_series.time_unit
        conv_fac = time_series.time._conversion_factor

    this_time = time_series.time / float(conv_fac)
    ax.plot(this_time, time_series.data.T, **kwargs)

    if xlabel is None:
        ax.set_xlabel('Time (%s)' % tu)
    else:
        ax.set_xlabel(xlabel)

    if ylabel is not None:
        ax.set_ylabel(ylabel)

    if yerror is not None:
        if len(yerror.data.shape) == 1:
            this_e = yerror.data[np.newaxis, :]
        else:
            this_e = yerror.data
        delta = this_e
        e_u = time_series.data + delta
        e_d = time_series.data - delta
        for i in range(e_u.shape[0]):
            ax.fill_between(this_time, e_d[i], e_u[i], alpha=error_alpha)

    return fig
pl.xlabel(r'$n$', size = 'large')
pl.ylabel(r'$\delta \mathrm{ F}\,\, \frac{ 8 \pi D^{2} }{k_{B} T}$')
pl.legend(loc = 'best')
pl.text(75,-0.053,r'Total $\delta F( \omega_0 = 4.2) = %.2f$' % sum_dF_042, color='b')
pl.text(75,-0.056,r'Total $\delta F( \omega_0 = 6.2) = %.2f$' % sum_dF_062, color='g')
pl.text(75,-0.059,r'Total $\delta F( \omega_0 = 8.2) = %.2f$' % sum_dF_082, color='r')
pl.text(75,-0.062,r'Total $\delta F(\omega_0 = 10.2) = %.2f$' % sum_dF_102, color='c')
pl.text(75,-0.065,r'Total $\delta F(\omega_0 = 13.2) = %.2f$' % sum_dF_132, color='m')
pl.text(75,-0.068,r'Total $\delta F(\omega_0 = 18.2) = %.2f$' % sum_dF_182, color='y')

pp.savefig()
pl.show()

fig = pl.figure()
ax = fig.add_axes([0.1,0.1,0.8,0.8])
ax.plot(x_peak,  y_peak,   color = 'g',label = r'Synthesized')# $\epsilon$"($\omega$)', linestyle='-')
ax.plot(x_nopeak,y_nopeak, color = 'b',label = r'Ab initio')# $\epsilon$"($\omega$)',   linestyle='-')
ax.legend(loc = 'best')
#pl.title(r'$\epsilon$"($\omega$)  Ab Initio and Synthisized')
pl.xlabel(r'$\omega$', size = 'x-large')
pl.ylabel(r'$\epsilon$"($\omega$)', size = 'x-large')

ax_inset = fig.add_axes([0.55,0.42,0.3,0.3])
ax_inset.plot(x_nopeak,diff_eps,color='r',label=r'$\epsilon$"($\omega)_{synthesized}$-$\epsilon$"($\omega)_{ab\,initio}$')
#ax_inset.plot(x_nopeak*1e-16,diff_eps,color='r',label=r'$\epsilon$"($\omega)_{synthesized}$-$\epsilon$"($\omega)_{ab\,initio}$')
#ax_inset.plot(x_nopeak*1e-16,listofzeros,color = 'k', label=r'$\delta$$\epsilon$"($\omega$) = 0')
ax_inset.plot(x_nopeak,listofzeros,color = 'k', label=r'$\delta$$\epsilon$"($\omega$) = 0')
#pl.title(r'Difference $\epsilon$"($\omega$)', size = 'small')
pl.tick_params(labelsize = 'small')
pl.xlabel(r'$\omega$', size = 'small')
pl.ylabel(r'$\delta$$\epsilon$"($\omega$)', size = 'small')
Ejemplo n.º 22
0
def makeplot_recurrence(sequence, sequence2, recurrence_table, f_sequence,
                        s_sequence):

    recurrence_table = np.array(
        np.reshape(recurrence_table, (sequence2, sequence)).tolist())
    # create list of coordinates for requrence plot
    x_rqa = []
    y_rqa = []
    for y in range(0, 2 * sequence2, 2):
        for x in range(0, 2 * sequence, 2):
            if recurrence_table[int(y / 2)][int(x / 2)] == 1:
                x_rqa.append(x)
                y_rqa.append((2 * sequence2 - y - 1))

    multi_plot = plt.figure(figsize=(12, 9))
    multi_plot.clear()
    ax = multi_plot.add_subplot(1, 1, 1)
    # ax1 = plt.subplot2grid((8, 8), (0, 0), colspan=6, rowspan=2)
    # ax1.plot(list(range(len(count_y))), count_y)
    # plt.ylim(0, max(count_y) + 1)
    # plt.xlim(0,len(count_y)-1)
    # ax2 = plt.subplot2grid((8, 8), (2, 0), rowspan=6, colspan=6)
    if sequence > 100 or sequence2 > 100:
        size = 0.5
    else:
        size = 3

    wsp = [[x, y] for x, y in zip(x_rqa, y_rqa)]
    print(wsp)
    if wsp:
        wsp_spr = wsp[0]
        x = []
        y = []
    while len(wsp) > 1:
        wsp.remove(wsp_spr)
        if [wsp_spr[0] + 2, wsp_spr[1] - 2] in wsp:
            x.append(wsp_spr[0])
            y.append(wsp_spr[1])
            wsp_spr = [wsp_spr[0] + 2, wsp_spr[1] - 2]
            print(x, y)
        else:
            x.append(wsp_spr[0])
            y.append(wsp_spr[1])

            wsp_spr = wsp[0]
            print(x, y)
            if len(x) == 1:
                ax.plot(x, y, 'ro', markersize=1.5)
            else:
                ax.plot(x, y, 'r')
            x = []
            y = []
    if len(wsp) == 1:
        x.append(wsp[0][0])
        y.append(wsp[0][1])
        if len(x) == 1:
            ax.plot(x, y, 'ro', markersize=1.5)
        else:
            ax.plot(x, y, 'r')
        x = []
        y = []

    plt.xlim(-1, (2 * sequence) - 2)
    plt.ylim(0, 2 * sequence2)
    plt.xticks(range(0, 2 * sequence, 2), f_sequence)
    plt.yticks(range(1, 2 * sequence2 + 1, 2), s_sequence[::-1])
    minorLocator = MultipleLocator(5)
    minor_xticks = np.arange(1, 2 * sequence, 2)
    minor_yticks = np.arange(0, 2 * sequence2, 2)
    ax.xaxis.tick_top()
    ax.set_xticks(minor_xticks, minor=True)
    ax.set_yticks(minor_yticks, minor=True)
    plt.grid(which='minor', alpha=0.5)

    multi_plot.canvas.draw()
    multi_plot.savefig('static/RQA.png')
Ejemplo n.º 23
0
#pl.figure()
#pl.plot(z_y,yA/yA[0], color = 'b', label = 'A = 1.0')
#pl.plot(z_y,yB/yB[0], color = 'g', label = 'B = 4.0')
#pl.plot(z_y,yC/yC[0], color = 'r', label = 'C = 6.0')
#pl.title(r'Function $y(\xi)$ from $eqn\,6$')
#pl.tick_params(labelsize = 'small')
#pl.xlabel(r'$0<\frac{\xi}{\omega_0}<2$', size = 'x-large')
#pl.ylabel(r'$y(\xi)$', size = 'x-large')# \mathrm{ F}\,\, \frac{ 8 \pi D^{2} }{k_{B} T}$')
#pl.legend(loc = 'best')
#pl.axis([0.0, 2.2,0.0,1.2])
#pp.savefig()
#pl.show()
##############################################################
fig = pl.figure()
ax = fig.add_axes([0.1,0.1,0.8,0.8])
ax.plot(x_peak  , y_peak,   color = 'g',label = r'Synthesized')# $\epsilon$"($\omega$)', linestyle='-')
ax.plot(x_nopeak, y_nopeak, color = 'b',label = r'Ab initio')# $\epsilon$"($\omega$)',   linestyle='-')
#ax.legend(loc = 'best')
#pl.title(r'$\epsilon$"($\omega$)  Ab Initio and Synthisized')
pl.xlabel(r'$\omega$', size = 22)
pl.ylabel(r'$\epsilon$"($\omega$)', size = 21)

ax_inset = fig.add_axes([0.53,0.50,0.36,0.36])
ax_inset.plot(x_nopeak,diff_eps,color='r',label=r'$\epsilon$"($\omega)_{synthesized}$-$\epsilon$"($\omega)_{ab\,initio}$')
ax_inset.plot(x_nopeak,listofzeros,color = 'k', label=r'$\delta$$\epsilon$"($\omega$) = 0')
#pl.title(r'Difference $\epsilon$"($\omega$)', size = 'small')
pl.tick_params(labelsize = 'small')
pl.xlabel(r'$\omega$', size = 14)
pl.ylabel(r'$\delta$$\epsilon$"($\omega$)', size = 14)
#pp.savefig()
#pl.savefig('130807_plots/fig2a_eps2_deps2.pdf')
F_3 = -sum_Li3
F_3_p = -sum_Li3_p
diff_F = -F_3 + F_3_p
divide = dF / diff_F

## calc difference eps2 and eiz for with and without peak
# -----------------------------------------------------------
diff_eps = y_peak - y_nopeak
diff_eiz = eiz_peak - eiz_nopeak
listofzeros = numpy.zeros(len(x_nopeak))  # plot line for y = 0

## PLOTS
# -------------------------------------------------------------
fig = pl.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
ax.plot(x_peak, y_peak, color="g", label=r"Synthesized")  # $\epsilon$"($\omega$)', linestyle='-')
ax.plot(x_nopeak, y_nopeak, color="b", label=r"Ab initio")  # $\epsilon$"($\omega$)',   linestyle='-')
ax.legend(loc="best")
# pl.title(r'$\epsilon$"($\omega$)  Ab Initio and Synthisized')
pl.xlabel(r"$\omega$", size="large")
pl.ylabel(r'$\epsilon$"($\omega$)')

ax_inset = fig.add_axes([0.55, 0.42, 0.3, 0.3])
ax_inset.plot(
    x_nopeak * 1e-16,
    diff_eps,
    color="r",
    label=r'$\epsilon$"($\omega)_{synthesized}$-$\epsilon$"($\omega)_{ab\,initio}$',
)
ax_inset.plot(x_nopeak * 1e-16, listofzeros, color="k", label=r'$\delta$$\epsilon$"($\omega$) = 0')
# pl.title(r'Difference $\epsilon$"($\omega$)', size = 'small')
Ejemplo n.º 25
0
def plot_tseries(time_series, fig=None, axis=0,
                 xticks=None, xunits=None, yticks=None, yunits=None,
                 xlabel=None, ylabel=None, yerror=None, error_alpha=0.1,
                 time_unit=None, **kwargs):

    """plot a timeseries object

    Arguments
    ---------

    time_series: a nitime time-series object

    fig: a figure handle, opens a new figure if None

    subplot: an axis number (if there are several in the figure to be opened),
        defaults to 0.

    xticks: optional, list, specificies what values to put xticks on. Defaults
    to the matlplotlib-generated.

    yticks: optional, list, specificies what values to put xticks on. Defaults
    to the matlplotlib-generated.

    xlabel: optional, list, specificies what labels to put on xticks

    ylabel: optional, list, specificies what labels to put on yticks

    yerror: optional, UniformTimeSeries with the same sampling_rate and number
    of samples and channels as time_series, the error will be displayed as a
    shading above and below the plotted time-series

    """

    if fig is None:
        fig = plt.figure()

    if not fig.get_axes():
        ax = fig.add_subplot(1, 1, 1)
    else:
        ax = fig.get_axes()[axis]

    #Make sure that time displays on the x axis with the units you want:
    #If you want to change the time-unit on the visualization from that used to
    #represent the time-series:
    if time_unit is not None:
        tu = time_unit
        conv_fac = ts.time_unit_conversion[time_unit]
    #Otherwise, get the information from your input:
    else:
        tu = time_series.time_unit
        conv_fac = time_series.time._conversion_factor

    this_time = time_series.time / float(conv_fac)
    ax.plot(this_time, time_series.data.T, **kwargs)

    if xlabel is None:
        ax.set_xlabel('Time (%s)' % tu)
    else:
        ax.set_xlabel(xlabel)

    if ylabel is not None:
        ax.set_ylabel(ylabel)

    if yerror is not None:
        if len(yerror.data.shape) == 1:
            this_e = yerror.data[np.newaxis, :]
        else:
            this_e = yerror.data
        delta = this_e
        e_u = time_series.data + delta
        e_d = time_series.data - delta
        for i in range(e_u.shape[0]):
            ax.fill_between(this_time, e_d[i], e_u[i], alpha=error_alpha)

    return fig
fig = pl.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
for r in range(len(A_dep)):
    labels = r'$A\, =\, %.2f$' % A_dep[r]
    for t in range(len(z_y)):
        sum_Li2_A_dep[t] = 0.0
        for u in arange(1, 101):
            sum_Li2_A_dep[t] += ((
                (A_dep[r] / (A_dep[r] + 2. * z_y[t]**2 + 2))**2)**u) / (u**2)
        yA_dep[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))*\
        (1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))

        yA_dep_exp[t] = (sum_Li2_A_dep[t])*\
        ((1. - ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2))))**2)/\
        ((A_dep[r]/(1.+z_y[t]**2)) / (2.+(A_dep[r]/(1.+z_y[t]**2)))))#*\
        #(1./(1.+z_y[t]**2))/(1. + A_dep[r]/(1+z_y[t]**2))
        Aiz = [2.0 * y_dep * dee for y_dep, dee in zip(yA_dep_exp, de_e)]
    ax.plot(n / 12., Aiz, linestyle=':',
            color='y')  #,  color = colors[r], label = labels)
    total = trapz(yA_dep, z_y)
    print total
    ax.plot(z_y, yA_dep)  #,  color = colors[r], label = labels)
pl.xlabel(r'$\xi/\omega_{0}$', size=21)
pl.ylabel(r'$ A(\xi/\omega_{0} ) $', size=21)

pl.show()
pl.close()