solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.0__py3-none-any.whl

tests/fitfunctions/test_exponentials.py

@@ -0,0 +1,342 @@
+"""Tests for exponential fit functions."""
+
+import inspect
+import numpy as np
+import pytest
+
+from solarwindpy.fitfunctions.exponentials import (
+    Exponential,
+    ExponentialPlusC,
+    ExponentialCDF,
+)
+
+
+@pytest.mark.parametrize(
+    "cls, expected_params, sample_args, expected_shape",
+    [
+        (Exponential, ("x", "c", "A"), (0.0, 1.0, 2.0), ()),
+        (ExponentialPlusC, ("x", "c", "A", "d"), (0.0, 1.0, 2.0, 0.5), ()),
+        (ExponentialCDF, ("x", "c"), (0.0, 1.0), ()),
+    ],
+)
+def test_function_signature_and_output(
+    cls, expected_params, sample_args, expected_shape
+):
+    """Test function signatures and basic output for exponential classes."""
+    x = np.linspace(0.0, 2.0, 10)
+    y = np.ones_like(x)
+    obj = cls(x, y)
+
+    # ExponentialCDF needs y0 to be set before function can be called
+    if cls.__name__ == "ExponentialCDF":
+        obj.set_y0(1.0)
+
+    # Test function signature
+    sig = inspect.signature(obj.function)
+    assert tuple(sig.parameters.keys()) == expected_params
+
+    # Test function call
+    result = obj.function(*sample_args)
+    assert np.isscalar(result) or result.shape == expected_shape
+    assert np.isfinite(result)
+
+
+@pytest.fixture
+def exponential_data():
+    """Generate synthetic exponential data for testing."""
+    np.random.seed(42)
+    x = np.linspace(0, 3, 30)
+    c, A = 0.8, 3.0
+    noise = np.random.normal(0, 0.1, size=x.shape)
+    y = A * np.exp(-c * x) + noise
+    w = np.ones_like(x)
+    return x, y, w
+
+
+@pytest.mark.parametrize("cls", [Exponential, ExponentialPlusC, ExponentialCDF])
+def test_p0_zero_size_input(cls):
+    """Test p0 behavior with zero-size input arrays."""
+    x = np.array([])
+    y = np.array([])
+    obj = cls(x, y)
+
+    with pytest.raises((ValueError, AssertionError)):
+        _ = obj.p0
+
+
+def test_exponential_p0_estimation(exponential_data):
+    """Test initial parameter estimation for Exponential class."""
+    x, y, w = exponential_data
+    obj = Exponential(x, y)
+    obj.make_fit()
+
+    p0 = obj.p0
+    assert len(p0) == 2
+    assert isinstance(p0[0], (int, float))  # c
+    assert isinstance(p0[1], (int, float))  # A
+    assert p0[1] > 0  # A should be positive for exponential decay
+
+
+def test_exponential_plus_c_p0_estimation(exponential_data):
+    """Test initial parameter estimation for ExponentialPlusC class."""
+    x, y, w = exponential_data
+    # Add constant offset to data
+    y_offset = y + 0.5
+    obj = ExponentialPlusC(x, y_offset)
+    obj.make_fit()
+
+    p0 = obj.p0
+    assert len(p0) == 3
+    assert isinstance(p0[0], (int, float))  # c
+    assert isinstance(p0[1], (int, float))  # A
+    assert isinstance(p0[2], (int, float))  # d
+
+
+def test_exponential_cdf_p0_estimation(exponential_data):
+    """Test initial parameter estimation for ExponentialCDF class."""
+    x, y, w = exponential_data
+    # Transform to CDF-like data
+    y_cdf = np.cumsum(y) / np.sum(y)
+    obj = ExponentialCDF(x, y_cdf)
+    obj.set_y0(1.0)  # Set amplitude before fitting
+
+    p0 = obj.p0
+    assert len(p0) == 1
+    assert isinstance(p0[0], (int, float))  # c
+
+
+@pytest.mark.parametrize(
+    "cls, expected_tex",
+    [
+        (Exponential, r"f(x)=A \cdot e^{-cx}"),
+        (ExponentialPlusC, r"f(x)=A \cdot e^{-cx} + d"),
+        (ExponentialCDF, r"f(x)=A \left(1 - e^{-cx}\right)"),
+    ],
+)
+def test_TeX_function_strings(cls, expected_tex):
+    """Test TeX function representation strings."""
+    x = np.array([1.0, 2.0])
+    y = np.array([1.0, 0.5])
+    obj = cls(x, y)
+    assert obj.TeX_function == expected_tex
+
+
+def test_make_fit_success_regular(exponential_data):
+    """Test successful fitting for regular exponential classes."""
+    x, y, w = exponential_data
+
+    for cls in [Exponential, ExponentialPlusC]:
+        obj = cls(x, y)
+
+        # Test fitting succeeds
+        obj.make_fit()
+
+        # Test fit results are available
+        assert obj.popt is not None
+        assert obj.pcov is not None
+        assert obj.chisq_dof is not None
+        assert obj.fit_result is not None
+
+        # Test output shapes
+        assert len(obj.popt) == len(obj.p0)
+
+
+def test_make_fit_success_cdf(exponential_data):
+    """Test successful fitting for ExponentialCDF class."""
+    x, y, w = exponential_data
+    # Transform to CDF-like data
+    y_cdf = np.cumsum(y) / np.sum(y)
+
+    obj = ExponentialCDF(x, y_cdf)
+    obj.set_y0(1.0)  # Set amplitude before fitting
+
+    # Test fitting succeeds
+    obj.make_fit()
+
+    # Test fit results are available
+    assert obj.popt is not None
+    assert obj.pcov is not None
+    assert obj.chisq_dof is not None
+    assert obj.fit_result is not None
+
+    # Test output shapes
+    assert len(obj.popt) == len(obj.p0)
+
+
+def test_make_fit_insufficient_data():
+    """Test fitting failure with insufficient data."""
+    # Test Exponential and ExponentialPlusC
+    for cls in [Exponential, ExponentialPlusC]:
+        x = np.array([1.0])  # Single point
+        y = np.array([1.0])
+        obj = cls(x, y)
+
+        # By default, make_fit returns exceptions rather than raising them
+        result = obj.make_fit()
+        assert isinstance(result, ValueError)
+        assert "insufficient data" in str(result).lower()
+
+    # Test ExponentialCDF (needs special setup)
+    # Note: ExponentialCDF has only 1 parameter (c) so 1 data point is technically sufficient
+    # The fit will succeed but may not be meaningful
+    x = np.array([1.0])
+    y = np.array([1.0])
+    obj = ExponentialCDF(x, y)
+    obj.set_y0(1.0)
+
+    result = obj.make_fit()
+    # For ExponentialCDF with 1 point, the fit technically succeeds 
+    # (1 point for 1 parameter), so it returns None
+    assert result is None or isinstance(result, ValueError)
+    if isinstance(result, ValueError):
+        assert "insufficient data" in str(result).lower()
+
+
+def test_exponential_numerical_stability():
+    """Test exponential function handles large negative exponents."""
+    x = np.array([0.0, 10.0, 100.0])  # Large x values
+    y = np.array([1.0, 0.1, 0.01])
+    obj = Exponential(x, y)
+
+    # Should not raise overflow warnings
+    result = obj.function(100.0, 1.0, 1.0)  # exp(-100) -> very small
+    assert np.isfinite(result)
+    assert result >= 0
+
+
+def test_exponential_plus_c_constant_term():
+    """Test that ExponentialPlusC handles constant offset correctly."""
+    x = np.linspace(0, 2, 20)
+    c, A, d = 1.0, 2.0, 0.5
+    y_true = A * np.exp(-c * x) + d
+
+    obj = ExponentialPlusC(x, y_true)
+    result = obj.function(x, c, A, d)
+
+    assert np.allclose(result, y_true, rtol=1e-10)
+
+
+def test_exponential_cdf_monotonicity():
+    """Test that ExponentialCDF produces monotonically increasing output."""
+    x = np.linspace(0, 5, 20)
+    c = 0.5
+
+    obj = ExponentialCDF(x, np.ones_like(x))  # Dummy y data
+    obj.set_y0(1.0)  # Set amplitude
+    result = obj.function(x, c)
+
+    # CDF should be monotonically increasing
+    assert np.all(np.diff(result) >= 0)
+    # Should approach y0 as x increases
+    assert result[-1] < obj.y0  # Not quite reaching y0 for finite x
+    assert result[-1] > 0.9 * obj.y0  # But close to it
+
+
+def test_str_and_call_methods_regular(exponential_data):
+    """Test string representation and callable interface for regular exponentials."""
+    x, y, w = exponential_data
+
+    for cls in [Exponential, ExponentialPlusC]:
+        obj = cls(x, y)
+        obj.make_fit()
+
+        # Test string representation
+        str_repr = str(obj)
+        assert cls.__name__ in str_repr
+
+        # Test callable interface
+        x_test = np.array([0.5, 1.0, 1.5])
+        y_pred = obj(x_test)
+        assert y_pred.shape == x_test.shape
+        assert np.all(np.isfinite(y_pred))
+
+
+def test_str_and_call_methods_cdf(exponential_data):
+    """Test string representation and callable interface for ExponentialCDF."""
+    x, y, w = exponential_data
+    # Transform to CDF-like data
+    y_cdf = np.cumsum(y) / np.sum(y)
+
+    obj = ExponentialCDF(x, y_cdf)
+    obj.set_y0(1.0)  # Set amplitude before fitting
+    obj.make_fit()
+
+    # Test string representation
+    str_repr = str(obj)
+    assert "ExponentialCDF" in str_repr
+
+    # Test callable interface
+    x_test = np.array([0.5, 1.0, 1.5])
+    y_pred = obj(x_test)
+    assert y_pred.shape == x_test.shape
+    assert np.all(np.isfinite(y_pred))
+
+
+def test_exponential_decay_behavior():
+    """Test that Exponential produces proper decay behavior."""
+    x = np.linspace(0, 3, 10)
+    y = 2.0 * np.exp(-0.5 * x)  # True exponential decay
+
+    obj = Exponential(x, y)
+    obj.make_fit()
+
+    # Check that function values decrease with x
+    x_test = np.array([0.0, 1.0, 2.0, 3.0])
+    y_test = obj(x_test)
+
+    # Should be decreasing
+    assert np.all(np.diff(y_test) < 0)
+    # Should be positive
+    assert np.all(y_test > 0)
+
+
+@pytest.mark.parametrize("cls", [Exponential, ExponentialPlusC, ExponentialCDF])
+def test_property_access_before_fit(cls):
+    """Test accessing properties before fitting raises appropriate errors."""
+    x = np.array([1.0, 2.0, 3.0])
+    y = np.array([1.0, 0.5, 0.25])
+    obj = cls(x, y)
+
+    # These should work before fitting
+    assert obj.TeX_function is not None
+    assert obj.p0 is not None
+
+    # These should raise AttributeError before fitting
+    with pytest.raises(AttributeError):
+        _ = obj.popt
+    with pytest.raises(AttributeError):
+        _ = obj.pcov
+
+
+def test_exponential_with_weights(exponential_data):
+    """Test exponential fitting with observation weights."""
+    x, y, w = exponential_data
+
+    # Create varying weights (higher weight for early points)
+    w_varied = np.linspace(2.0, 0.5, len(x))
+
+    obj = Exponential(x, y, weights=w_varied)
+    obj.make_fit()
+
+    # Should complete successfully
+    assert obj.popt is not None
+    assert len(obj.popt) == 2
+
+
+@pytest.mark.parametrize("cls", [Exponential, ExponentialPlusC, ExponentialCDF])
+def test_edge_case_single_parameter_bounds(cls):
+    """Test behavior with extreme parameter values."""
+    x = np.array([0.0, 1.0, 2.0])
+    y = np.array([1.0, 0.5, 0.25])
+    obj = cls(x, y)
+
+    # Test with very small decay constant
+    if cls == Exponential:
+        result = obj.function(x, 1e-6, 1.0)  # Very slow decay
+        assert np.allclose(result, 1.0, atol=1e-5)
+
+    # Test with very large decay constant
+    if cls == Exponential:
+        result = obj.function(x, 100.0, 1.0)  # Very fast decay
+        assert result[0] == 1.0  # At x=0
+        assert result[-1] < 1e-40  # At x=2, essentially zero

tests/fitfunctions/test_gaussians.py

@@ -0,0 +1,142 @@
+import inspect
+import numpy as np
+import pytest
+
+from solarwindpy.fitfunctions.gaussians import (
+    Gaussian,
+    GaussianNormalized,
+    GaussianLn,
+)
+
+
+@pytest.mark.parametrize(
+    "cls, expected_params, sample_args, expected_output",
+    [
+        (Gaussian, ("x", "mu", "sigma", "A"), (0.0, 0.0, 1.0, 1.0), 1.0),
+        (
+            GaussianNormalized,
+            ("x", "mu", "sigma", "n"),
+            (0.0, 0.0, 1.0, 1.0),
+            1.0 / (np.sqrt(2 * np.pi)),
+        ),
+        (GaussianLn, ("x", "m", "s", "A"), (1.0, 0.0, 1.0, 1.0), 1.0),
+    ],
+)
+def test_function_signature_and_output(
+    cls, expected_params, sample_args, expected_output
+):
+    x = np.linspace(-1.0, 1.0, 5)
+    y = np.ones_like(x)
+    obj = cls(x, y)
+    sig = inspect.signature(obj.function)
+    assert tuple(sig.parameters.keys()) == expected_params
+    xval, *params = sample_args
+    assert np.allclose(obj.function(xval, *params), expected_output)
+
+
+@pytest.mark.parametrize("cls", [Gaussian, GaussianNormalized, GaussianLn])
+def test_p0_zero_size_input(cls):
+    x = np.array([])
+    y = np.array([])
+    obj = cls(x, y)
+    with pytest.raises(ValueError, match="insufficient data"):
+        _ = obj.p0
+
+
+@pytest.mark.parametrize(
+    "cls, params",
+    [
+        (Gaussian, dict(mu=1.0, sigma=0.5, amp=2.0)),
+        (GaussianNormalized, dict(mu=1.0, sigma=0.5, n=5.0)),
+        (GaussianLn, dict(m=0.3, s=0.2, A=3.0)),
+    ],
+)
+def test_p0_estimation(cls, params):
+    if cls is Gaussian:
+        x = np.linspace(
+            params["mu"] - 5 * params["sigma"], params["mu"] + 5 * params["sigma"], 100
+        )
+        y = params["amp"] * np.exp(-0.5 * ((x - params["mu"]) / params["sigma"]) ** 2)
+        mean = (x * y).sum() / y.sum()
+        std = np.sqrt(((x - mean) ** 2 * y).sum() / y.sum())
+        peak = y.max()
+        expected = [mean, std, peak]
+    elif cls is GaussianNormalized:
+        x = np.linspace(
+            params["mu"] - 5 * params["sigma"], params["mu"] + 5 * params["sigma"], 100
+        )
+        A = params["n"] / (np.sqrt(2 * np.pi) * params["sigma"])
+        y = A * np.exp(-0.5 * ((x - params["mu"]) / params["sigma"]) ** 2)
+        mean = (x * y).sum() / y.sum()
+        std = np.sqrt(((x - mean) ** 2 * y).sum() / y.sum())
+        peak = y.max()
+        n_est = peak * std * np.sqrt(2 * np.pi)
+        expected = [mean, std, n_est]
+    else:  # GaussianLn
+        x = np.linspace(
+            np.exp(params["m"] - 5 * params["s"]),
+            np.exp(params["m"] + 5 * params["s"]),
+            100,
+        )
+        lnx = np.log(x)
+        y = params["A"] * np.exp(-0.5 * ((lnx - params["m"]) / params["s"]) ** 2)
+        mean = (x * y).sum() / y.sum()
+        std = ((x - mean) ** 2 * y).sum() / y.sum()
+        peak = y.max()
+        expected = [np.log(mean), np.log(std), np.log(peak)]
+    obj = cls(x, y)
+    assert np.allclose(obj.p0, expected)
+
+
+@pytest.mark.parametrize(
+    "cls, expected",
+    [
+        (
+            Gaussian,
+            r"f(x)=A \cdot e^{-\frac{1}{2} \left(\frac{x-\mu}{\sigma}\right)^2}",
+        ),
+        (
+            GaussianNormalized,
+            r"f(x)=\frac{n}{\sqrt{2 \pi} \sigma} e^{-\frac{1}{2} \left(\frac{x-\mu}{\sigma}\right)^2}",
+        ),
+        (
+            GaussianLn,
+            (
+                r"f(x) =A \cdot"
+                r"\exp\left["
+                r"\frac{\left(\ln x - m\right)^2}{2 s^2}"
+                r"\right]"
+            ),
+        ),
+    ],
+)
+def test_TeX_function_strings(cls, expected):
+    x = np.linspace(0.0, 1.0, 5)
+    y = np.ones_like(x)
+    obj = cls(x, y)
+    assert obj.TeX_function == expected
+
+
+@pytest.mark.parametrize("cls", [Gaussian, GaussianNormalized])
+def test_make_fit_TeX_argnames_success(cls):
+    mu, sigma = 0.0, 0.5
+    x = np.linspace(mu - sigma, mu + sigma, 5)
+    if cls is Gaussian:
+        A = 1.0
+        y = A * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
+    else:
+        n = 1.0
+        A = n / (np.sqrt(2 * np.pi) * sigma)
+        y = A * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
+    obj = cls(x, y)
+    obj.make_fit()
+    assert obj.TeX_info.TeX_argnames == {"mu": r"\mu", "sigma": r"\sigma"}
+
+
+@pytest.mark.parametrize("cls", [Gaussian, GaussianNormalized])
+def test_make_fit_TeX_argnames_failure(cls):
+    x = np.linspace(0.0, 1.0, 2)
+    y = np.ones_like(x)
+    obj = cls(x, y)
+    obj.make_fit(return_exception=True)
+    assert not hasattr(obj, "_TeX_info")