def _fft_method(tbt, num_harmonics):
samples = tbt[:] # Copy the samples array.
n = float(len(samples))
dft_data = _fft(samples)
indices = np.argsort(np.abs(dft_data))[::-1][:num_harmonics]
frequencies = indices / n
coefficients = dft_data[indices] / n
return frequencies, coefficients
def _fft_method(tbt, num_harmonics):
samples = tbt[:] # Copy the samples array.
n = float(len(samples))
dft_data = _fft(samples)
indices = np.argsort(np.abs(dft_data))[::-1][:num_harmonics]
frequencies = indices / n
coefficients = dft_data[indices] / n
return frequencies, coefficients
def dft(x, null_hypothesis=None, counts=1):
"""
Returns the discrete Fourier transform of y, with a unitary normalization, where
y is an array with elements related to the x array by
y = (x - counts * null_hypothesis) / sqrt(counts * null_hypothesis * (1-null_hypothesis)),
where the arithmetic is element-wise, and `null_hypothesis` is a vector in (0,1).
If `null_hypothesis` is None it is set to the mean of x. If that mean is 0 or 1 then
the vector of all ones, except for the first element which is set to zero, is returned.
Parameters
----------
x : array
Data string, on which the normalization and discrete cosine transformation is performed. If
counts is not specified, this must be a bit string.
null_hypothesis : array, optional
If not None, an array to use in the normalization before the dct. If None, it is
taken to be an array in which every element is the mean of x.
counts : int, optional
A factor in the normalization, that should correspond to the counts-per-timestep (so
for full time resolution this is 1).
Returns
-------
array
The DFT modes described above.
"""
standardized_x = standardizer(x, null_hypothesis, counts)
if standardized_x is None:
out = _np.ones(len(x))
out[0] = 0.
return out
modes = _fft(standardized_x) / _np.sqrt(len(x))
return modes
def _laskar_method(tbt, num_harmonics):
samples = tbt[:] # Copy the samples array.
n = len(samples)
int_range = np.arange(n)
coefficients = []
frequencies = []
for _ in range(num_harmonics):
# Compute this harmonic frequency and coefficient.
dft_data = _fft(samples)
frequency = _jacobsen(dft_data, n)
coefficient = _compute_coef(samples, frequency * n) / n
# Store frequency and amplitude
coefficients.append(coefficient)
frequencies.append(frequency)
# Subtract the found pure tune from the signal
new_signal = coefficient * np.exp(PI2I * frequency * int_range)
samples = samples - new_signal
coefficients, frequencies = zip(*sorted(zip(coefficients, frequencies),
key=lambda tuple: np.abs(tuple[0]),
reverse=True))
return frequencies, coefficients
def _laskar_method(tbt, num_harmonics):
samples = tbt[:] # Copy the samples array.
n = len(samples)
int_range = np.arange(n)
coefficients = []
frequencies = []
for _ in range(num_harmonics):
# Compute this harmonic frequency and coefficient.
dft_data = _fft(samples)
frequency = _jacobsen(dft_data, n)
coefficient = _compute_coef(samples, frequency * n) / n
# Store frequency and amplitude
coefficients.append(coefficient)
frequencies.append(frequency)
# Subtract the found pure tune from the signal
new_signal = coefficient * np.exp(PI2I * frequency * int_range)
samples = samples - new_signal
coefficients, frequencies = zip(*sorted(zip(coefficients, frequencies),
key=lambda tuple: np.abs(tuple[0]),
reverse=True))
return frequencies, coefficients