def test_nterms_methods(method, center_data, fit_mean, errors,
nterms, normalization, data):
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError(f"Unrecognized error type: '{errors}'")
ls = LombScargle(t, y, dy, center_data=center_data,
fit_mean=fit_mean, nterms=nterms,
normalization=normalization)
if nterms == 0 and not fit_mean:
with pytest.raises(ValueError) as err:
ls.power(frequency, method=method)
assert 'nterms' in str(err.value) and 'bias' in str(err.value)
else:
P_expected = ls.power(frequency)
# don't use fast fft approximations here
kwds = {}
if 'fast' in method:
kwds['method_kwds'] = dict(use_fft=False)
P_method = ls.power(frequency, method=method, **kwds)
assert_allclose(P_expected, P_method, rtol=1E-7, atol=1E-25)
def test_nterms_methods(method, center_data, fit_mean, errors,
nterms, normalization, data):
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError("Unrecognized error type: '{0}'".format(errors))
ls = LombScargle(t, y, dy, center_data=center_data,
fit_mean=fit_mean, nterms=nterms,
normalization=normalization)
if nterms == 0 and not fit_mean:
with pytest.raises(ValueError) as err:
ls.power(frequency, method=method)
assert 'nterms' in str(err.value) and 'bias' in str(err.value)
else:
P_expected = ls.power(frequency)
# don't use fast fft approximations here
kwds = {}
if 'fast' in method:
kwds['method_kwds'] = dict(use_fft=False)
P_method = ls.power(frequency, method=method, **kwds)
assert_allclose(P_expected, P_method, rtol=1E-7, atol=1E-25)
def test_all_methods(data, method, center_data, fit_mean, errors, with_units,
normalization):
if method == 'scipy' and (fit_mean or errors != 'none'):
return
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if with_units:
t = t * units.day
y = y * units.mag
dy = dy * units.mag
frequency = frequency / t.unit
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError("Unrecognized error type: '{0}'".format(errors))
kwds = {}
ls = LombScargle(t,
y,
dy,
center_data=center_data,
fit_mean=fit_mean,
normalization=normalization)
P_expected = ls.power(frequency)
# don't use the fft approximation here; we'll test this elsewhere
if method in FAST_METHODS:
kwds['method_kwds'] = dict(use_fft=False)
P_method = ls.power(frequency, method=method, **kwds)
if with_units:
if normalization == 'psd' and errors == 'none':
assert P_method.unit == y.unit**2
else:
assert P_method.unit == units.dimensionless_unscaled
else:
assert not hasattr(P_method, 'unit')
assert_quantity_allclose(P_expected, P_method)
def test_all_methods(data, method, center_data, fit_mean,
errors, with_units, normalization):
if method == 'scipy' and (fit_mean or errors != 'none'):
return
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if with_units:
t = t * u.day
y = y * u.mag
dy = dy * u.mag
frequency = frequency / t.unit
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError("Unrecognized error type: '{0}'".format(errors))
kwds = {}
ls = LombScargle(t, y, dy, center_data=center_data, fit_mean=fit_mean,
normalization=normalization)
P_expected = ls.power(frequency)
# don't use the fft approximation here; we'll test this elsewhere
if method in FAST_METHODS:
kwds['method_kwds'] = dict(use_fft=False)
P_method = ls.power(frequency, method=method, **kwds)
if with_units:
if normalization == 'psd' and errors == 'none':
assert P_method.unit == y.unit ** 2
else:
assert P_method.unit == u.dimensionless_unscaled
else:
assert not hasattr(P_method, 'unit')
assert_quantity_allclose(P_expected, P_method)
def test_autopower(data):
t, y, dy = data
ls = LombScargle(t, y, dy)
kwargs = dict(samples_per_peak=6, nyquist_factor=2,
minimum_frequency=2, maximum_frequency=None)
freq1 = ls.autofrequency(**kwargs)
power1 = ls.power(freq1)
freq2, power2 = ls.autopower(**kwargs)
assert_allclose(freq1, freq2)
assert_allclose(power1, power2)
def test_autopower(data):
t, y, dy = data
ls = LombScargle(t, y, dy)
kwargs = dict(samples_per_peak=6, nyquist_factor=2,
minimum_frequency=2, maximum_frequency=None)
freq1 = ls.autofrequency(**kwargs)
power1 = ls.power(freq1)
freq2, power2 = ls.autopower(**kwargs)
assert_allclose(freq1, freq2)
assert_allclose(power1, power2)
def test_fast_approximations(method, center_data, fit_mean, errors, nterms,
data):
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError("Unrecognized error type: '{0}'".format(errors))
ls = LombScargle(t,
y,
dy,
center_data=center_data,
fit_mean=fit_mean,
nterms=nterms,
normalization='standard')
# use only standard normalization because we compare via absolute tolerance
kwds = dict(method=method)
if method == 'fast' and nterms != 1:
with pytest.raises(ValueError) as err:
ls.power(frequency, **kwds)
assert 'nterms' in str(err.value)
elif nterms == 0 and not fit_mean:
with pytest.raises(ValueError) as err:
ls.power(frequency, **kwds)
assert 'nterms' in str(err.value) and 'bias' in str(err.value)
else:
P_fast = ls.power(frequency, **kwds)
kwds['method_kwds'] = dict(use_fft=False)
P_slow = ls.power(frequency, **kwds)
assert_allclose(P_fast, P_slow, atol=0.008)
def test_fast_approximations(method, center_data, fit_mean,
errors, nterms, data):
t, y, dy = data
frequency = 0.8 + 0.01 * np.arange(40)
if errors == 'none':
dy = None
elif errors == 'partial':
dy = dy[0]
elif errors == 'full':
pass
else:
raise ValueError("Unrecognized error type: '{0}'".format(errors))
ls = LombScargle(t, y, dy, center_data=center_data,
fit_mean=fit_mean, nterms=nterms,
normalization='standard')
# use only standard normalization because we compare via absolute tolerance
kwds = dict(method=method)
if method == 'fast' and nterms != 1:
with pytest.raises(ValueError) as err:
ls.power(frequency, **kwds)
assert 'nterms' in str(err.value)
elif nterms == 0 and not fit_mean:
with pytest.raises(ValueError) as err:
ls.power(frequency, **kwds)
assert 'nterms' in str(err.value) and 'bias' in str(err.value)
else:
P_fast = ls.power(frequency, **kwds)
kwds['method_kwds'] = dict(use_fft=False)
P_slow = ls.power(frequency, **kwds)
assert_allclose(P_fast, P_slow, atol=0.008)
def test_absolute_times(data, timedelta):
# Make sure that we handle absolute times correctly. We also check that
# TimeDelta works properly when timedelta is True.
# The example data uses relative times
t, y, dy = data
# FIXME: There seems to be a numerical stability issue in that if we run
# the algorithm with the same values but offset in time, the transit_time
# is not offset by a fixed amount. To avoid this issue in this test, we
# make sure the first time is also the smallest so that internally the
# values of the relative time should be the same.
t[0] = 0.
# Add units
t = t * u.day
y = y * u.mag
dy = dy * u.mag
# We now construct a set of absolute times but keeping the rest the same
start = Time('2019-05-04T12:34:56')
trel = TimeDelta(t) if timedelta else t
t = trel + start
# and we set up two instances of LombScargle, one with absolute and one
# with relative times.
ls1 = LombScargle(t, y, dy)
ls2 = LombScargle(trel, y, dy)
kwargs = dict(samples_per_peak=6,
nyquist_factor=2,
minimum_frequency=2 / u.day,
maximum_frequency=None)
freq1 = ls1.autofrequency(**kwargs)
freq2 = ls2.autofrequency(**kwargs)
assert_quantity_allclose(freq1, freq2)
power1 = ls1.power(freq1)
power2 = ls2.power(freq2)
assert_quantity_allclose(power1, power2)
freq1, power1 = ls1.autopower(**kwargs)
freq2, power2 = ls2.autopower(**kwargs)
assert_quantity_allclose(freq1, freq2)
assert_quantity_allclose(power1, power2)
model1 = ls1.model(t, 2 / u.day)
model2 = ls2.model(trel, 2 / u.day)
assert_quantity_allclose(model1, model2)
# Check model validation
with pytest.raises(TypeError) as exc:
ls1.model(trel, 2 / u.day)
assert exc.value.args[0] == ('t was provided as a relative time but the '
'LombScargle class was initialized with '
'absolute times.')
with pytest.raises(TypeError) as exc:
ls2.model(t, 2 / u.day)
assert exc.value.args[0] == ('t was provided as an absolute time but the '
'LombScargle class was initialized with '
'relative times.')
# Check design matrix
design1 = ls1.design_matrix(2 / u.day, t=t)
design2 = ls2.design_matrix(2 / u.day, t=trel)
assert_quantity_allclose(design1, design2)
# Check design matrix validation
with pytest.raises(TypeError) as exc:
ls1.design_matrix(2 / u.day, t=trel)
assert exc.value.args[0] == ('t was provided as a relative time but the '
'LombScargle class was initialized with '
'absolute times.')
with pytest.raises(TypeError) as exc:
ls2.design_matrix(2 / u.day, t=t)
assert exc.value.args[0] == ('t was provided as an absolute time but the '
'LombScargle class was initialized with '
'relative times.')
def test_absolute_times(data, timedelta):
# Make sure that we handle absolute times correctly. We also check that
# TimeDelta works properly when timedelta is True.
# The example data uses relative times
t, y, dy = data
# FIXME: There seems to be a numerical stability issue in that if we run
# the algorithm with the same values but offset in time, the transit_time
# is not offset by a fixed amount. To avoid this issue in this test, we
# make sure the first time is also the smallest so that internally the
# values of the relative time should be the same.
t[0] = 0.
# Add units
t = t * u.day
y = y * u.mag
dy = dy * u.mag
# We now construct a set of absolute times but keeping the rest the same
start = Time('2019-05-04T12:34:56')
trel = TimeDelta(t) if timedelta else t
t = trel + start
# and we set up two instances of LombScargle, one with absolute and one
# with relative times.
ls1 = LombScargle(t, y, dy)
ls2 = LombScargle(trel, y, dy)
kwargs = dict(samples_per_peak=6, nyquist_factor=2,
minimum_frequency=2 / u.day, maximum_frequency=None)
freq1 = ls1.autofrequency(**kwargs)
freq2 = ls2.autofrequency(**kwargs)
assert_quantity_allclose(freq1, freq2)
power1 = ls1.power(freq1)
power2 = ls2.power(freq2)
assert_quantity_allclose(power1, power2)
freq1, power1 = ls1.autopower(**kwargs)
freq2, power2 = ls2.autopower(**kwargs)
assert_quantity_allclose(freq1, freq2)
assert_quantity_allclose(power1, power2)
model1 = ls1.model(t, 2 / u.day)
model2 = ls2.model(trel, 2 / u.day)
assert_quantity_allclose(model1, model2)
# Check model validation
with pytest.raises(TypeError) as exc:
ls1.model(trel, 2 / u.day)
assert exc.value.args[0] == ('t was provided as a relative time but the '
'LombScargle class was initialized with '
'absolute times.')
with pytest.raises(TypeError) as exc:
ls2.model(t, 2 / u.day)
assert exc.value.args[0] == ('t was provided as an absolute time but the '
'LombScargle class was initialized with '
'relative times.')
# Check design matrix
design1 = ls1.design_matrix(2 / u.day, t=t)
design2 = ls2.design_matrix(2 / u.day, t=trel)
assert_quantity_allclose(design1, design2)
# Check design matrix validation
with pytest.raises(TypeError) as exc:
ls1.design_matrix(2 / u.day, t=trel)
assert exc.value.args[0] == ('t was provided as a relative time but the '
'LombScargle class was initialized with '
'absolute times.')
with pytest.raises(TypeError) as exc:
ls2.design_matrix(2 / u.day, t=t)
assert exc.value.args[0] == ('t was provided as an absolute time but the '
'LombScargle class was initialized with '
'relative times.')