def test_percent_point_invalid_value(self):
"""Evaluating an invalid value will raise ValueError."""
fit_data = np.array([1, 2, 3, 4, 5])
instance = GaussianKDE()
instance.fit(fit_data)
with self.assertRaises(ValueError):
instance.percent_point(np.array([2.]))
def test_percent_point(self, kde_mock, brentq_mock, cdf_mock):
"""percent_point evaluates with the model."""
# Setup
model_mock = kde_mock.return_value
brentq_mock.return_value = -250.0
cdf_mock.return_value = 'a nice scalar bounded method'
fit_data = np.array([1, 2, 3, 4, 5])
instance = GaussianKDE()
instance.fit(fit_data)
expected_result = np.array([-250.0])
# Run
result = instance.percent_point([0.5])
# Check
assert result == expected_result
kde_mock.assert_called_once_with(fit_data)
model_mock.assert_not_called()
assert len(model_mock.method_calls) == 0
brentq_mock.assert_called_once_with('a nice scalar bounded method',
-1000, 1000)
def test_percent_point_bisect(self):
"""percent_point evaluates with the model."""
instance = GaussianKDE()
instance.fit(np.array([0.5, 1.0, 1.5]))
cdf = instance.percent_point(np.array([0.001, 0.5, 0.999]), method='bisect')
assert cdf[0] < 0.0, "The 0.001th percentile should be small."
assert abs(cdf[1] - 1.0) < 0.1, "The 50% percentile should be the median."
assert cdf[2] > 2.0, "The 0.999th percentile should be large."
def test_percent_point_constant_raises(self, ppf_mock):
"""If constant_value, percent_point uses the degenerate version."""
# Setup
instance = GaussianKDE()
instance.fitted = True
instance.constant_value = 3
instance._replace_constant_methods()
X = np.array([0.1, 0.5, 0.75])
expected_result = np.array([3, 3, 3])
ppf_mock.return_value = np.array([3, 3, 3])
# Run
result = instance.percent_point(X)
# Check
compare_nested_iterables(result, expected_result)
ppf_mock.assert_called_once_with(instance, X)
def test_percent_point_boundary_values(self):
instance = GaussianKDE()
instance.fit(np.array([0.0, 0.5, 1.0]))
x = instance.percent_point(np.array([0.0, 1.0]))
assert x[0] == float("-inf")
assert x[1] == float("inf")
def test_percent_point_invertibility(self):
instance = GaussianKDE()
instance.fit(sample_univariate_bimodal())
cdf = np.random.random(size=1000)
x = instance.percent_point(cdf)
assert np.abs(instance.cumulative_distribution(x) - cdf).max() < 1e-6
