Contributing Guide¶

from typing import List, Optional, Union

def test_one(self, p_value: float) -> bool:
    """
    Test a single p-value.

    Parameters
    ----------
    p_value : float
        P-value to test (0 ≤ p_value ≤ 1)

    Returns
    -------
    bool
        True if null hypothesis is rejected
    """
    pass

def method_name(param1: float, param2: str = "default") -> bool:
    """
    Brief description of the method.

    Longer description explaining the method's purpose,
    algorithm, and usage context.

    Parameters
    ----------
    param1 : float
        Description of first parameter
    param2 : str, optional
        Description of second parameter, by default "default"

    Returns
    -------
    bool
        Description of return value

    Raises
    ------
    ValueError
        When parameters are invalid

    Examples
    --------
    >>> method = ClassName(alpha=0.05)
    >>> result = method.method_name(0.01, "custom")
    >>> print(result)
    True

    References
    ----------
    .. [1] Author, A. "Paper Title." Journal Name (Year).
    """
    pass

from online_fdr.abstract.abstract_sequential_test import AbstractSequentialTest
from online_fdr.utils import validity

class NewMethod(AbstractSequentialTest):
    """
    Implementation of NewMethod for online FDR control.

    This method implements the algorithm described in [1]_.

    Parameters
    ----------
    alpha : float
        Target FDR level (0 < alpha < 1)
    param1 : float
        Method-specific parameter
    param2 : float, optional
        Optional method-specific parameter, by default 0.5

    References
    ----------
    .. [1] Author, A. "NewMethod: Description." Journal (Year).
    """

    def __init__(self, alpha: float, param1: float, param2: float = 0.5):
        super().__init__(alpha)

        # Validate parameters
        validity.check_alpha(alpha)
        validity.check_param1(param1)  # Add custom validation

        # Store parameters
        self.param1 = param1
        self.param2 = param2

        # Initialize state
        self.num_tests = 0
        self.wealth = alpha * 0.5  # Example initialization

    def test_one(self, p_value: float) -> bool:
        """
        Test a single p-value.

        Parameters
        ----------
        p_value : float
            P-value to test (0 ≤ p_value ≤ 1)

        Returns
        -------
        bool
            True if null hypothesis is rejected
        """
        validity.check_p_val(p_value)

        self.num_tests += 1

        # Calculate current threshold
        self.alpha = self._calculate_threshold()

        if self.alpha is None or p_value > self.alpha:
            return False

        # Update state after rejection
        self._update_wealth()
        return True

    def _calculate_threshold(self) -> Optional[float]:
        """Calculate current significance threshold."""
        if self.wealth <= 0:
            return None
        # Implement threshold calculation
        return self.wealth * self.param1

    def _update_wealth(self) -> None:
        """Update wealth after a discovery."""
        self.wealth += self.param2  # Example wealth update

# tests/test_new_method.py
import pytest
import numpy as np
from online_fdr.investing.new_method import NewMethod
from online_fdr.utils.generation import DataGenerator, GaussianLocationModel

class TestNewMethod:
    """Test suite for NewMethod."""

    def test_initialization(self):
        """Test proper initialization."""
        method = NewMethod(alpha=0.05, param1=0.25)
        assert method.alpha0 == 0.05
        assert method.param1 == 0.25
        assert method.param2 == 0.5  # default

    def test_invalid_parameters(self):
        """Test parameter validation."""
        with pytest.raises(ValueError):
            NewMethod(alpha=1.5, param1=0.25)  # Invalid alpha

        with pytest.raises(ValueError):
            NewMethod(alpha=0.05, param1=-0.1)  # Invalid param1

    def test_single_p_value(self):
        """Test single p-value testing."""
        method = NewMethod(alpha=0.05, param1=0.25)

        # Should reject small p-value
        assert method.test_one(0.001) is True

        # Should not reject large p-value
        assert method.test_one(0.9) is False

    def test_fdr_control_simulation(self):
        """Test FDR control through simulation."""
        np.random.seed(42)

        method = NewMethod(alpha=0.1, param1=0.25)

        # Generate data with known null proportion
        dgp = GaussianLocationModel(alt_mean=2.0, alt_std=1.0, one_sided=True)
        generator = DataGenerator(n=1000, pi0=0.9, dgp=dgp)

        true_positives = false_positives = 0

        for _ in range(100):
            p_value, is_alternative = generator.sample_one()
            decision = method.test_one(p_value)

            if decision:
                if is_alternative:
                    true_positives += 1
                else:
                    false_positives += 1

        # Check FDR control
        total_discoveries = true_positives + false_positives
        if total_discoveries > 0:
            empirical_fdr = false_positives / total_discoveries
            assert empirical_fdr <= 0.15  # Allow some variance

    def test_wealth_dynamics(self):
        """Test wealth updates correctly."""
        method = NewMethod(alpha=0.05, param1=0.25)
        initial_wealth = method.wealth

        # Make a discovery
        method.test_one(0.01)

        # Wealth should have changed appropriately
        assert method.wealth != initial_wealth

    def test_edge_cases(self):
        """Test edge cases and boundary conditions."""
        method = NewMethod(alpha=0.05, param1=0.25)

        # Test p-value = 0
        result = method.test_one(0.0)
        assert isinstance(result, bool)

        # Test p-value = 1
        result = method.test_one(1.0)
        assert isinstance(result, bool)

        # Test when wealth is depleted
        method.wealth = 0.0
        assert method.test_one(0.001) is False

def test_performance_benchmark(benchmark):
    """Benchmark method performance."""
    method = NewMethod(alpha=0.05, param1=0.25)
    p_values = np.random.uniform(0, 1, 1000)

    def run_tests():
        for p_val in p_values:
            method.test_one(p_val)

    benchmark(run_tests)