Software Implementation

MATLAB#

MATLAB can compute the cross-correlation between two signals using the xcorr function. Before version R2019a, xcorr was available as part of the Signal Processing Toolbox; however, starting from R2019a, it has been integrated into the core MATLAB environment.

The following example demonstrates how to perform cross-correlation using xcorr:


x =  [0 1 -1 3 -2 0];
y =  [0 0 1 -1 3 -2];

[r, lags] = xcorr(x, y, 'normalized')

Here, r contains the cross-correlation values, and lags provides the corresponding lag indices. The 'normalized' option normalizes the cross-correlation output.

For additional options and parameters available with xcorr, refer to the MATLAB documentation using the help xcorr command.

Python#

In Python, cross-correlation can be computed using the correlate function from the scipy.signal module. This function calculates the cross-correlation of two signals, similar to MATLAB's xcorr function.

The following code example demonstrates how to perform cross-correlation in Python:


import numpy as np
from scipy import signal

x = np.array([0, 1, -1, 3, -2, 0])
y = np.array([0, 0, 1, -1, 3, -2])

# Perform cross-correlation
r = signal.correlate(x, y)

# Calculate lags
lags = signal.correlation_lags(len(x), len(y))

# Normalize the cross-correlation
normFactor = np.sqrt(np.sum(x**2)) * np.sqrt(np.sum(y**2))
r = r / normFactor

In Python, cross-correlation can be computed using the correlate function from the scipy.signal module. This function calculates the cross-correlation of two signals, similar to MATLAB's xcorr function.

The following code example demonstrates how to perform cross-correlation in Python:

Explanation of the Code
  • Import the necessary modules. The numpy module is for numerical operations, and the scipy.signal from SciPy is used to calculate the correlation.
  • The signal.correlate(x, y) function computes the cross-correlation between the arrays x and y. By default, it returns the full cross-correlation, including negative, zero, and positive lags.
  • The signal.correlation_lags(len(x), len(y)) function returns the lag indices corresponding to the cross-correlation output. These lags indicate the relative displacement of the signals being compared.
  • The normalization step scales the cross-correlation output to ensure the result is comparable across different signals. The normalization factor, normFactor, is calculated as the product of the square roots of the sums of squares of the elements in x and y.
  • The cross-correlation result r is then divided by this normalization factor to yield the normalized cross-correlation, similar to what the 'normalized' option does in MATLAB.
Key Differences from MATLAB
  • In Python, normalization is done manually, whereas in MATLAB, the 'normalized' option within xcorr handles this automatically.

C#

In C, cross-correlation involves manually implementing the algorithm since there is no built-in function like in MATLAB or Python.

Below is an example of how you can implement cross-correlation and normalization in C:


#include <stdio.h>
#include <math.h>

void cross_correlation(double x[], double y[], int N, double r[], int* lags) {
    int i, j;
    int lag_index = 0;

    for (i = -(N - 1); i < N; i++) {
        double sum = 0.0;

        for (j = 0; j < N; j++) {
            if ((j - i) >= 0 && (j - i) < N) {
                sum += x[j] * y[j - i];
            }
        }
        r[lag_index] = sum;
        lags[lag_index] = i;
        lag_index++;
    }
}

double sum_of_squares(double arr[], int N) {
    double sum = 0.0;
    for (int i = 0; i < N; i++) {
        sum += arr[i] * arr[i];
    }
    return sum;
}

void normalize_cross_correlation(double r[], double x[], double y[], int N, int length) {
    double normFactor = sqrt(sum_of_squares(x, N) * sum_of_squares(y, N));
    for (int i = 0; i < length; i++) {
        r[i] /= normFactor;
    }
}

int main() {
    double x[] = { 0, 1, -1, 3, -2, 0 };
    double y[] = { 0, 0, 1, -1, 3, -2 };
    int N = sizeof(x) / sizeof(x[0]);
    int length = 2 * N - 1;
    double r[length];
    int lags[length];

    // Calculate cross-correlation
    cross_correlation(x, y, N, r, lags);

    // Normalize cross-correlation
    normalize_cross_correlation(r, x, y, N, length);

    // Print results
    printf("Cross-Correlation:\n");
    for (int i = 0; i < length; i++) {
        printf("Lag %d: %f\n", lags[i], r[i]);
    }

    return 0;
}
Explanation of the Code:
  • Cross-Correlation Calculation:
    • The cross_correlation function calculates the cross-correlation between two arrays x and y. It iterates over possible lag values, calculating the sum of products for each lag. The results are stored in the array r, and corresponding lags are stored in lags.
  • Normalization:
    • The normalize_cross_correlation function normalizes the cross-correlation result by dividing each value in r by a normalization factor. This factor is the square root of the product of the sums of squares of x and y.
    • The sum_of_squares helper function computes the sum of squares for a given array.
  • Printing the Results:
    • The main function runs the cross-correlation and normalization functions and then prints the normalized cross-correlation values and their corresponding lags.
Key Points:
  • In C, you manually implement the cross-correlation and normalization steps, providing complete control over the process but requiring more code than in higher-level languages like MATLAB or Python.
  • The cross-correlation algorithm shifts one signal over the other (from negative to positive lags) and calculates the sum of element-wise products for each shift.
  • Normalization ensures that the maximum possible value of the cross-correlation is scaled to 1, similar to the 'normalized' option in MATLAB.

This C implementation gives you full flexibility in handling cross-correlation and normalization, making it suitable for low-level or performance-critical applications.

Page Contents