docs: def synchronise_signals(in_signal_1, in_signal_2):
      """
      -----
      Brief
      -----
      This function synchronises the input signals using the full cross correlation function between the signals.
  
      -----------
      Description
      -----------
      Signals acquired with two devices may be dephased. It is possible to synchronise the two signals by multiple
      methods. Here, it is implemented a method that uses the calculus of the cross-correlation between those signals and
      identifies the correct instant of synchrony.
  
      This function synchronises the two input signals and returns the dephasing between them, and the resulting
      synchronised signals.
  
      ----------
      Parameters
      ----------
      in_signal_1 : list or numpy.array
          One of the input signals.
      in_signal_2 : list or numpy.array
          The other input signal.
  
      Returns
      -------
      phase : int
          The dephasing between signals in data points.
      result_signal_1: list or numpy.array
          The first signal synchronised.
      result_signal_2: list or numpy.array
          The second signal synchronised.
      """
  
      mean_1, std_1, mean_2, std_2 = [np.mean(in_signal_1), np.std(in_signal_1), np.mean(in_signal_2),
                                      np.std(in_signal_2)]
      signal_1 = in_signal_1 - mean_1
      signal_1 /= std_1
      signal_2 = in_signal_2 - mean_2
      signal_2 /= std_2
  
      # Calculate the full cross-correlation between the two signals.
      correlation = np.correlate(signal_1, signal_2, 'full')
  
      # Finding the edge of the correct correlation signal
      center = len(correlation) - len(signal_1) if len(signal_1) < len(signal_2) else len(correlation) - len(signal_2)
  
      # Finding the position of the maximum value of the correlation signal
      max_position = correlation.argmax()
      # Calculating the difference between the center and the position of the maximum value
      phase_straight = center - max_position
  
      # Finding the position of the maximum value of the reversed signal (corr[::-1])
      max_position_reversed = correlation[::-1].argmax()
      # Calculating the difference between the center and the position of the maximum value in the reversed correlation
      # signal
      phase_reversed = center - max_position_reversed
  
      # Calculate the dephasing between the signals. Maximum value of both results guarantees that we find the true
      # dephasing of the signals
      phases_aux = [phase_straight, phase_reversed]
      phase = np.abs(phases_aux).argmax()
      true_phase = np.abs(phases_aux[phase])
  
      if phases_aux[0] < phases_aux[1]:
          signal_1 = signal_1[true_phase:]
      else:
          signal_2 = signal_2[true_phase:]
  
      result_signal_1 = signal_1 * std_1 + mean_1
      result_signal_2 = signal_2 * std_2 + mean_2
  
      return true_phase, result_signal_1, result_signal_2