trexselector 0.6.0__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,46 @@
+"""
+Pytest configuration file.
+"""
+
+import os
+import sys
+import pytest
+import numpy as np
+
+# Add the package root to the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+@pytest.fixture
+def gaussian_data():
+    """
+    Fixture providing Gaussian test data similar to the R package's Gauss_data.
+    
+    Returns:
+        tuple: X, y, beta where:
+            X is the predictor matrix (n x p)
+            y is the response vector (n)
+            beta is the true coefficient vector (p)
+    """
+    # Set seed for reproducibility
+    np.random.seed(789)
+    
+    n, p = 50, 100
+    
+    # Generate predictor matrix
+    X = np.random.normal(0, 1, size=(n, p))
+    
+    # Scale X
+    X = (X - X.mean(axis=0)) / X.std(axis=0, ddof=1)
+    
+    # Generate true coefficient vector (3 non-zero coefficients)
+    beta = np.zeros(p)
+    beta[:3] = 3.0
+    
+    # Generate response vector
+    eps = np.random.normal(0, 1, size=n)
+    y = X @ beta + eps
+    
+    # Center y
+    y = y - y.mean()
+    
+    return X, y, beta 

tests/test_trexselector/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test package for trexselector.
+""" 

tests/test_trexselector/test_add_dummies.py

@@ -0,0 +1,60 @@
+"""
+Tests for the add_dummies function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import add_dummies
+
+def test_add_dummies_input_validation(gaussian_data):
+    """Test error control for inputs X and num_dummies."""
+    X, y, _ = gaussian_data
+    
+    # Tests for X
+    # Test X must be a 2D array
+    with pytest.raises(ValueError, match="'X' must be a 2D numpy array"):
+        add_dummies(X=X[:, 0], num_dummies=10)
+    
+    # Create X with NaNs
+    X_with_nan = X.copy()
+    X_with_nan[0, 0] = np.nan
+    
+    with pytest.raises(ValueError, match="'X' contains NaNs"):
+        add_dummies(X=X_with_nan, num_dummies=10)
+    
+    # Tests for num_dummies
+    # Test num_dummies must be an integer
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=0.5)
+    
+    # Test num_dummies must be >= 1
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=0)
+    
+    # Test num_dummies must not be negative
+    with pytest.raises(ValueError, match="'num_dummies' must be an integer larger or equal to 1"):
+        add_dummies(X=X, num_dummies=-10)
+
+def test_add_dummies_output_shape(gaussian_data):
+    """Test that the output shape of add_dummies is correct."""
+    X, _, _ = gaussian_data
+    
+    # Create a smaller test matrix
+    n, p = 20, 5
+    np.random.seed(42)
+    X_small = np.random.randn(n, p)
+    
+    # Test with different numbers of dummies
+    for num_dummies in [1, 2, 3]:
+        X_Dummy = add_dummies(X=X_small, num_dummies=num_dummies)
+        
+        # Check shape
+        assert X_Dummy.shape == (n, p + num_dummies), f"Expected shape {(n, p + num_dummies)}, got {X_Dummy.shape}"
+        
+        # Check that the first p columns are identical to X
+        np.testing.assert_allclose(X_Dummy[:, :p], X_small)
+        
+        # Check that the dummy variables are standardized with more tolerance
+        for j in range(p, p + num_dummies):
+            assert abs(X_Dummy[:, j].mean()) < 1e-10, f"Dummy column {j} is not centered"
+            assert abs(X_Dummy[:, j].std() - 1.0) < 1e-10, f"Dummy column {j} is not standardized" 

tests/test_trexselector/test_fdp.py

@@ -0,0 +1,81 @@
+"""
+Tests for the FDP (False Discovery Proportion) function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import FDP, trex
+
+def test_fdp_input_validation_beta_hat(gaussian_data):
+    """Test error control for input beta_hat."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta_hat with NAs
+    beta_hat_with_nan = beta_hat.copy()
+    beta_hat_with_nan[np.random.choice(len(beta_hat), size=10)] = np.nan
+    
+    # Tests
+    # Test beta_hat must be 1D array
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        FDP(beta_hat=np.column_stack([beta_hat, beta_hat]), beta=beta)
+    
+    # Test beta_hat must be numeric
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat.astype(str), beta=beta)
+    
+    # Test beta_hat cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta_hat' contains NaNs"):
+        FDP(beta_hat=beta_hat_with_nan, beta=beta)
+
+def test_fdp_input_validation_beta(gaussian_data):
+    """Test error control for input beta."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta with NAs
+    beta_with_nan = beta.copy()
+    beta_with_nan[np.random.choice(len(beta), size=10)] = np.nan
+    
+    # Tests
+    # Test beta must be 1D array
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat, beta=np.column_stack([beta, beta]))
+    
+    # Test beta must be numeric
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        FDP(beta_hat=beta_hat, beta=beta.astype(str))
+    
+    # Test beta cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta' contains NaNs"):
+        FDP(beta_hat=beta_hat, beta=beta_with_nan)
+    
+    # Test length of beta_hat must match length of beta
+    with pytest.raises(ValueError, match="Shapes of 'beta_hat' and 'beta' must match"):
+        FDP(beta_hat=np.concatenate([beta_hat, beta_hat]), beta=beta)
+
+def test_fdp_value_range(gaussian_data):
+    """Test that the value of FDP is in the interval [0, 1]."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Compute FDP
+    fdp = FDP(beta_hat=beta_hat, beta=beta)
+    
+    # Test FDP is in [0, 1]
+    assert 0 <= fdp <= 1, f"FDP value {fdp} is outside the expected range [0, 1]" 

tests/test_trexselector/test_tpp.py

@@ -0,0 +1,81 @@
+"""
+Tests for the TPP (True Positive Proportion) function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import TPP, trex
+
+def test_tpp_input_validation_beta_hat(gaussian_data):
+    """Test error control for input beta_hat."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta_hat with NAs
+    beta_hat_with_nan = beta_hat.copy()
+    beta_hat_with_nan[np.random.choice(len(beta_hat), size=10)] = np.nan
+    
+    # Tests
+    # Test beta_hat must be 1D array
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        TPP(beta_hat=np.column_stack([beta_hat, beta_hat]), beta=beta)
+    
+    # Test beta_hat must be numeric
+    with pytest.raises(ValueError, match="'beta_hat' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat.astype(str), beta=beta)
+    
+    # Test beta_hat cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta_hat' contains NaNs"):
+        TPP(beta_hat=beta_hat_with_nan, beta=beta)
+
+def test_tpp_input_validation_beta(gaussian_data):
+    """Test error control for input beta."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Create beta with NAs
+    beta_with_nan = beta.copy()
+    beta_with_nan[np.random.choice(len(beta), size=10)] = np.nan
+    
+    # Tests
+    # Test beta must be 1D array
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat, beta=np.column_stack([beta, beta]))
+    
+    # Test beta must be numeric
+    with pytest.raises(ValueError, match="'beta' must be a 1D numpy array"):
+        TPP(beta_hat=beta_hat, beta=beta.astype(str))
+    
+    # Test beta cannot contain NaNs
+    with pytest.raises(ValueError, match="'beta' contains NaNs"):
+        TPP(beta_hat=beta_hat, beta=beta_with_nan)
+    
+    # Test length of beta_hat must match length of beta
+    with pytest.raises(ValueError, match="Shapes of 'beta_hat' and 'beta' must match"):
+        TPP(beta_hat=np.concatenate([beta_hat, beta_hat]), beta=beta)
+
+def test_tpp_value_range(gaussian_data):
+    """Test that the value of TPP is in the interval [0, 1]."""
+    X, y, beta = gaussian_data
+    
+    # Run T-Rex to get beta_hat
+    np.random.seed(1234)
+    res = trex(X, y, verbose=False)
+    beta_hat = np.zeros(beta.shape[0])
+    beta_hat[res["selected_var"]] = 1
+    
+    # Compute TPP
+    tpp = TPP(beta_hat=beta_hat, beta=beta)
+    
+    # Test TPP is in [0, 1]
+    assert 0 <= tpp <= 1, f"TPP value {tpp} is outside the expected range [0, 1]" 

tests/test_trexselector/test_trex.py

@@ -0,0 +1,103 @@
+"""
+Tests for the main trex function.
+"""
+
+import pytest
+import numpy as np
+from trexselector import trex
+
+def test_trex_input_validation_method_type(gaussian_data):
+    """Test error control for inputs method and type."""
+    X, y, _ = gaussian_data
+    
+    # Test method must be one of the allowed values
+    with pytest.raises(ValueError, match="'method' must be one of"):
+        trex(X=X, y=y, method="test")
+    
+    # Test type must be one of the allowed values
+    with pytest.raises(ValueError, match="'type' must be one of"):
+        trex(X=X, y=y, type="test")
+
+def test_trex_input_validation_X(gaussian_data):
+    """Test error control for input X."""
+    X, y, _ = gaussian_data
+    
+    # Test X must be a 2D array
+    with pytest.raises(ValueError, match="'X' must be a 2D numpy array"):
+        trex(X=X[:, 0], y=y)
+    
+    # Create X with NaNs
+    X_with_nan = X.copy()
+    X_with_nan[0, 0] = np.nan
+    
+    with pytest.raises(ValueError, match="'X' contains NaNs"):
+        trex(X=X_with_nan, y=y)
+    
+    # Test X with non-numeric values - this will either raise when creating the X array
+    # or during standardization, so we just check for any ValueError
+    with pytest.raises(Exception):
+        trex(X=X.astype(str), y=y)
+
+def test_trex_input_validation_y(gaussian_data):
+    """Test error control for input y."""
+    X, y, _ = gaussian_data
+    
+    # Test y must be a 1D array
+    with pytest.raises(ValueError, match="'y' must be a 1D numpy array"):
+        trex(X=X, y=np.column_stack([y, y]))
+    
+    # Create y with NaNs
+    y_with_nan = y.copy()
+    y_with_nan[0] = np.nan
+    
+    # Check for a ValueError with a message containing "NaN" (case insensitive)
+    with pytest.raises(ValueError, match="NaN"):
+        trex(X=X, y=y_with_nan)
+    
+    # Test X and y must have compatible shapes
+    with pytest.raises(ValueError, match="Number of rows in X must match length of y"):
+        trex(X=X, y=y[:-1])
+
+def test_trex_input_validation_parameters(gaussian_data):
+    """Test error control for other parameters."""
+    X, y, _ = gaussian_data
+    
+    # Test tFDR must be between 0 and 1
+    with pytest.raises(ValueError, match="'tFDR' must be a number between 0 and 1"):
+        trex(X=X, y=y, tFDR=-0.1)
+    
+    with pytest.raises(ValueError, match="'tFDR' must be a number between 0 and 1"):
+        trex(X=X, y=y, tFDR=1.1)
+    
+    # Test K must be >= 2
+    with pytest.raises(ValueError, match="The number of random experiments 'K' must be an integer larger or equal to 2"):
+        trex(X=X, y=y, K=1)
+    
+    # Test max_num_dummies must be >= 1
+    with pytest.raises(ValueError, match="'max_num_dummies' must be an integer larger or equal to 1"):
+        trex(X=X, y=y, max_num_dummies=0)
+
+def test_trex_basic_functionality(gaussian_data):
+    """Test that trex produces the expected output."""
+    X, y, beta = gaussian_data
+    
+    # Run trex with minimal parameters
+    np.random.seed(1234)
+    res = trex(X=X, y=y, tFDR=0.2, K=5, max_num_dummies=1, verbose=False)
+    
+    # Check that the output contains the expected keys
+    expected_keys = [
+        "selected_var", "tFDR", "T_stop", "num_dummies", "V", "v_thresh"
+    ]
+    for key in expected_keys:
+        assert key in res, f"Expected key {key} not found in result"
+    
+    # Check that selected_var is a numpy array
+    assert isinstance(res["selected_var"], np.ndarray), "selected_var should be a numpy array"
+    
+    # Check that T_stop is a positive integer
+    assert isinstance(res["T_stop"], int), "T_stop should be an integer"
+    assert res["T_stop"] > 0, "T_stop should be positive"
+    
+    # Check that the number of dummies is as expected
+    assert res["num_dummies"] == X.shape[1], "num_dummies should be p in the first iteration" 

trexselector/__init__.py

@@ -0,0 +1,19 @@
+"""
+TRexSelector: T-Rex Selector for High-Dimensional Variable Selection & FDR Control
+
+This package performs fast variable selection in high-dimensional settings while 
+controlling the false discovery rate (FDR) at a user-defined target level.
+"""
+
+from .trex import trex
+from .random_experiments import random_experiments
+from .lm_dummy import lm_dummy
+from .screen_trex import screen_trex
+from .add_dummies import add_dummies, add_dummies_GVS
+from .fdp import FDP, TPP, fdp_hat
+from .select_var_fun import select_var_fun
+from .select_var_fun_DA_BT import select_var_fun_DA_BT
+from .phi_prime_fun import Phi_prime_fun
+from .gauss_data import generate_gaussian_data
+
+__version__ = '0.6.0'

trexselector/add_dummies.py

@@ -0,0 +1,142 @@
+"""
+Functions for adding dummy variables to the predictor matrix
+"""
+
+import numpy as np
+from scipy.cluster.hierarchy import linkage, fcluster
+from scipy.spatial.distance import pdist
+
+def add_dummies(X, num_dummies):
+    """
+    Add random dummy variables to the predictor matrix.
+    
+    Parameters
+    ----------
+    X : ndarray, shape (n, p)
+        Predictor matrix.
+    num_dummies : int
+        Number of dummies to append to the predictor matrix.
+    
+    Returns
+    -------
+    ndarray, shape (n, p + num_dummies)
+        Predictor matrix with appended dummies.
+    """
+    # Error control
+    if not isinstance(X, np.ndarray) or X.ndim != 2:
+        raise ValueError("'X' must be a 2D numpy array.")
+    
+    if not np.issubdtype(X.dtype, np.number):
+        raise ValueError("'X' only allows numerical values.")
+    
+    if np.any(np.isnan(X)):
+        raise ValueError("'X' contains NaNs. Please remove or impute them before proceeding.")
+    
+    if not isinstance(num_dummies, int) or num_dummies < 1:
+        raise ValueError("'num_dummies' must be an integer larger or equal to 1.")
+    
+    # Number of rows and columns in X
+    n, p = X.shape
+    
+    # Generate dummy variables
+    np.random.seed(0)  # For reproducibility
+    dummies = np.random.normal(0, 1, size=(n, num_dummies))
+    
+    # Scale dummies more carefully to ensure exact standardization
+    dummies = dummies - dummies.mean(axis=0)
+    stds = dummies.std(axis=0, ddof=1)
+    dummies = dummies / stds
+    
+    # Verify standardization
+    assert np.allclose(dummies.mean(axis=0), 0, atol=1e-10)
+    assert np.allclose(dummies.std(axis=0, ddof=1), 1, atol=1e-10)
+    
+    # Append dummies to X
+    X_Dummy = np.hstack((X, dummies))
+    
+    return X_Dummy
+
+def add_dummies_GVS(X, num_dummies, corr_max=0.5):
+    """
+    Add dummy variables with correlation constraints for group variable selection.
+    
+    Parameters
+    ----------
+    X : ndarray, shape (n, p)
+        Predictor matrix.
+    num_dummies : int
+        Number of dummies to append to the predictor matrix.
+    corr_max : float, default=0.5
+        Maximum allowed correlation between any two predictors from different clusters.
+    
+    Returns
+    -------
+    dict
+        A dictionary containing:
+        - X_Dummy: Predictor matrix with appended dummies
+        - max_clusters: Maximum number of clusters
+        - cluster_sizes: Size of each cluster
+        - IEN_cl_id_vectors: Cluster identity vectors for Informed Elastic Net (IEN)
+    """
+    # Error control
+    if not isinstance(X, np.ndarray) or X.ndim != 2:
+        raise ValueError("'X' must be a 2D numpy array.")
+    
+    if not isinstance(num_dummies, int) or num_dummies < 1:
+        raise ValueError("'num_dummies' must be an integer larger or equal to 1.")
+    
+    if not isinstance(corr_max, float) or corr_max < 0 or corr_max > 1:
+        raise ValueError("'corr_max' must be a float between 0 and 1.")
+    
+    # Number of rows and columns in X
+    n, p = X.shape
+    
+    if num_dummies % p != 0:
+        raise ValueError("'num_dummies' must be a positive integer multiple of the number of original predictors in X.")
+    
+    # Number of dummies per predictor
+    num_dummies_per_pred = num_dummies // p
+    
+    # Compute correlation matrix
+    corr_mat = np.corrcoef(X, rowvar=False)
+    
+    # Compute distance matrix: 1 - |corr_mat|
+    dist_mat = 1 - np.abs(corr_mat)
+    
+    # Hierarchical clustering
+    Z = linkage(pdist(X.T), method='single')
+    
+    # Determine clusters: cut tree at height 1 - corr_max
+    clusters = fcluster(Z, 1 - corr_max, criterion='distance') - 1  # 0-based indexing
+    
+    # Number of clusters
+    max_clusters = len(np.unique(clusters))
+    
+    # Cluster sizes
+    unique_clusters, cluster_sizes = np.unique(clusters, return_counts=True)
+    
+    # Create IEN cluster identity vectors
+    IEN_cl_id_vectors = np.zeros((p, max_clusters))
+    for j in range(p):
+        IEN_cl_id_vectors[j, clusters[j]] = 1
+    
+    # Initialize X_Dummy
+    X_Dummy = np.copy(X)
+    
+    # Add dummies for each original predictor
+    for j in range(p):
+        # Generate dummies for this predictor
+        x_dummies = np.random.normal(0, 1, size=(n, num_dummies_per_pred))
+        
+        # Scale dummies
+        x_dummies = (x_dummies - x_dummies.mean(axis=0)) / x_dummies.std(axis=0, ddof=1)
+        
+        # Append to X_Dummy
+        X_Dummy = np.hstack((X_Dummy, x_dummies))
+    
+    return {
+        "X_Dummy": X_Dummy,
+        "max_clusters": max_clusters,
+        "cluster_sizes": cluster_sizes,
+        "IEN_cl_id_vectors": IEN_cl_id_vectors
+    } 

trexselector/fdp.py

@@ -0,0 +1,145 @@
+"""
+Functions for computing false discovery proportion (FDP) and true positive proportion (TPP)
+"""
+
+import numpy as np
+
+def FDP(beta_hat, beta, eps=np.finfo(float).eps):
+    """
+    Compute the false discovery proportion (FDP).
+    
+    Parameters
+    ----------
+    beta_hat : ndarray
+        Estimated coefficient vector.
+    beta : ndarray
+        True coefficient vector.
+    eps : float, default=machine epsilon
+        Numerical zero.
+    
+    Returns
+    -------
+    float
+        False discovery proportion.
+    """
+    # Error control
+    if not isinstance(beta_hat, np.ndarray) or beta_hat.ndim != 1:
+        raise ValueError("'beta_hat' must be a 1D numpy array.")
+    
+    if not np.issubdtype(beta_hat.dtype, np.number):
+        raise ValueError("'beta_hat' must be a 1D numpy array of numeric values.")
+    
+    if np.any(np.isnan(beta_hat)):
+        raise ValueError("'beta_hat' contains NaNs. Please remove or impute them before proceeding.")
+    
+    if not isinstance(beta, np.ndarray) or beta.ndim != 1:
+        raise ValueError("'beta' must be a 1D numpy array.")
+    
+    if not np.issubdtype(beta.dtype, np.number):
+        raise ValueError("'beta' must be a 1D numpy array of numeric values.")
+    
+    if np.any(np.isnan(beta)):
+        raise ValueError("'beta' contains NaNs. Please remove or impute them before proceeding.")
+    
+    if beta_hat.shape != beta.shape:
+        raise ValueError("Shapes of 'beta_hat' and 'beta' must match.")
+    
+    # Number of estimated variables
+    R = np.sum(np.abs(beta_hat) > eps)
+    
+    # If no variable is selected, the FDP is defined as 0
+    if R == 0:
+        return 0.0
+    
+    # False discoveries
+    V = np.sum((np.abs(beta_hat) > eps) & (np.abs(beta) <= eps))
+    
+    # False discovery proportion
+    return V / R
+
+def TPP(beta_hat, beta, eps=np.finfo(float).eps):
+    """
+    Compute the true positive proportion (TPP).
+    
+    Parameters
+    ----------
+    beta_hat : ndarray
+        Estimated coefficient vector.
+    beta : ndarray
+        True coefficient vector.
+    eps : float, default=machine epsilon
+        Numerical zero.
+    
+    Returns
+    -------
+    float
+        True positive proportion.
+    """
+    # Error control
+    if not isinstance(beta_hat, np.ndarray) or beta_hat.ndim != 1:
+        raise ValueError("'beta_hat' must be a 1D numpy array.")
+    
+    if not np.issubdtype(beta_hat.dtype, np.number):
+        raise ValueError("'beta_hat' must be a 1D numpy array of numeric values.")
+    
+    if np.any(np.isnan(beta_hat)):
+        raise ValueError("'beta_hat' contains NaNs. Please remove or impute them before proceeding.")
+    
+    if not isinstance(beta, np.ndarray) or beta.ndim != 1:
+        raise ValueError("'beta' must be a 1D numpy array.")
+    
+    if not np.issubdtype(beta.dtype, np.number):
+        raise ValueError("'beta' must be a 1D numpy array of numeric values.")
+    
+    if np.any(np.isnan(beta)):
+        raise ValueError("'beta' contains NaNs. Please remove or impute them before proceeding.")
+    
+    if beta_hat.shape != beta.shape:
+        raise ValueError("Shapes of 'beta_hat' and 'beta' must match.")
+    
+    # Number of true non-zero coefficients
+    S = np.sum(np.abs(beta) > eps)
+    
+    # If there are no true non-zero coefficients, the TPP is defined as 0
+    if S == 0:
+        return 0.0
+    
+    # True positives
+    T = np.sum((np.abs(beta_hat) > eps) & (np.abs(beta) > eps))
+    
+    # True positive proportion
+    return T / S
+
+def fdp_hat(V, Phi, Phi_prime):
+    """
+    Compute the estimated FDP for a set of voting thresholds.
+    
+    Parameters
+    ----------
+    V : ndarray
+        Voting thresholds.
+    Phi : ndarray
+        Vector of relative occurrences.
+    Phi_prime : ndarray
+        Vector of expected relative occurrences.
+    
+    Returns
+    -------
+    ndarray
+        Estimated FDP for each voting threshold.
+    """
+    p = len(Phi)
+    V_len = len(V)
+    
+    # Initialize estimated FDP
+    FDP_hat = np.zeros(V_len)
+    
+    # Compute estimated FDP for each voting threshold
+    for i, v in enumerate(V):
+        R = np.sum(Phi >= v)
+        if R == 0:
+            FDP_hat[i] = 0.0
+        else:
+            FDP_hat[i] = np.sum(Phi_prime * (Phi >= v)) / R
+    
+    return FDP_hat