Spécifier le retard dans Numpy.CorLate

Je recommanderais de regarder Ce fichier pour déterminer comment vous voudrait mettre en œuvre la corrélation décrite ici .

Ceci est ma mise en œuvre de la corrélation de lag en plomb, mais elle est limitée à 1-D et non garanti d'être le meilleur en termes d'efficacité. Il utilise les scripes.stats.peersonr vers le calcul de base, donc également renvoyé est la valeur P du coefficient. Veuillez modifier pour optimiser en fonction de cet homme de paille.

def lagcorr(x,y,lag=None,verbose=True):
    '''Compute lead-lag correlations between 2 time series.

    <x>,<y>: 1-D time series.
    <lag>: lag option, could take different forms of <lag>:
          if 0 or None, compute ordinary correlation and p-value;
          if positive integer, compute lagged correlation with lag
          upto <lag>;
          if negative integer, compute lead correlation with lead
          upto <-lag>;
          if pass in an list or tuple or array of integers, compute 
          lead/lag correlations at different leads/lags.

    Note: when talking about lead/lag, uses <y> as a reference.
    Therefore positive lag means <x> lags <y> by <lag>, computation is
    done by shifting <x> to the left hand side by <lag> with respect to
    <y>.
    Similarly negative lag means <x> leads <y> by <lag>, computation is
    done by shifting <x> to the right hand side by <lag> with respect to
    <y>.

    Return <result>: a (n*2) array, with 1st column the correlation 
    coefficients, 2nd column correpsonding p values.

    Currently only works for 1-D arrays.
    '''

    import numpy
    from scipy.stats import pearsonr

    if len(x)!=len(y):
        raise('Input variables of different lengths.')

    #--------Unify types of <lag>-------------
    if numpy.isscalar(lag):
        if abs(lag)>=len(x):
            raise('Maximum lag equal or larger than array.')
        if lag<0:
            lag=-numpy.arange(abs(lag)+1)
        elif lag==0:
            lag=[0,]
        else:
            lag=numpy.arange(lag+1)    
    elif lag is None:
        lag=[0,]
    else:
        lag=numpy.asarray(lag)

    #-------Loop over lags---------------------
    result=[]
    if verbose:
        print '\n#<lagcorr>: Computing lagged-correlations at lags:',lag

    for ii in lag:
        if ii<0:
            result.append(pearsonr(x[:ii],y[-ii:]))
        elif ii==0:
            result.append(pearsonr(x,y))
        elif ii>0:
            result.append(pearsonr(x[ii:],y[:-ii]))

    result=numpy.asarray(result)

    return result

matplotlib.xcor a le paramètre maxlags param. C'est en fait une enveloppe du numpy.corrélate , donc il n'y a pas d'économie de performance. Néanmoins, cela donne exactement le même résultat donné par la fonction de corrélation croisée de Matlab. Ci-dessous j'ai édité le code de Maxplotlib afin de ne renvoyer que la corrélation. La raison en est que si nous utilisons matplotlib.corr tel qu'il est, il retournera également l'intrigue. Le problème est que si nous mettons un type de données complexes comme des arguments, nous obtiendrons "Coulement complexe à un réel DataType de DataType" lorsque Matplotlib tente de dessiner la parcelle. xxx