LORD: Levels based On Recent Discovery¶

from online_fdr.investing.lord.three import LordThree

# Create LORD 3 instance with recommended parameters
lord3 = LordThree(alpha=0.05, wealth=0.025, reward=0.025)

# Test individual p-values
p_values = [0.001, 0.15, 0.03, 0.8, 0.02, 0.45, 0.006]

print("LORD 3 Online Testing:")
discoveries = []

for i, p_value in enumerate(p_values):
    decision = lord3.test_one(p_value)

    if decision:
        discoveries.append(i + 1)
        print(f"✓ Test {i+1}: p={p_value:.3f} → DISCOVERY! (wealth: {lord3.wealth:.4f})")
    else:
        print(f"  Test {i+1}: p={p_value:.3f} → no rejection (wealth: {lord3.wealth:.4f})")

print(f"\nTotal discoveries: {len(discoveries)}")
print(f"Final wealth: {lord3.wealth:.4f}")

def demonstrate_wealth_dynamics():
    """Show how LORD 3 manages alpha-wealth over time."""

    lord3 = LordThree(alpha=0.1, wealth=0.05, reward=0.05)

    print("LORD 3 Wealth Dynamics:")
    print("=" * 30)
    print(f"Initial wealth: {lord3.wealth:.4f}")

    test_scenarios = [
        (0.001, "Very small p-value"),
        (0.8, "Large p-value"),  
        (0.02, "Small p-value after discovery"),
        (0.5, "Medium p-value"),
        (0.005, "Another small p-value")
    ]

    for i, (p_value, description) in enumerate(test_scenarios, 1):
        wealth_before = lord3.wealth
        decision = lord3.test_one(p_value)
        wealth_after = lord3.wealth

        status = "REJECT" if decision else "ACCEPT"
        wealth_change = wealth_after - wealth_before

        print(f"Test {i}: p={p_value:.3f} ({description})")
        print(f"  Decision: {status}")
        print(f"  Wealth: {wealth_before:.4f} → {wealth_after:.4f} (change: {wealth_change:+.4f})")
        print()

demonstrate_wealth_dynamics()

def compare_lord_parameters():
    """Compare LORD 3 performance with different parameters."""

    # Test different parameter combinations
    configs = [
        {"name": "Conservative", "wealth": 0.01, "reward": 0.04},
        {"name": "Moderate", "wealth": 0.025, "reward": 0.025},  
        {"name": "Aggressive", "wealth": 0.04, "reward": 0.01},
    ]

    test_p_values = [0.001, 0.02, 0.15, 0.003, 0.8, 0.01, 0.4, 0.005]

    print("LORD 3 Parameter Comparison:")
    print("=" * 40)

    for config in configs:
        lord3 = LordThree(alpha=0.05, 
                         wealth=config["wealth"], 
                         reward=config["reward"])

        decisions = [lord3.test_one(p) for p in test_p_values]
        discoveries = sum(decisions)

        print(f"{config['name']:>12} (W₀={config['wealth']:.3f}, R={config['reward']:.3f}): "
              f"{discoveries} discoveries")

compare_lord_parameters()

from online_fdr.investing.addis.addis import Addis
from online_fdr.investing.saffron.saffron import Saffron

def compare_online_methods(p_values):
    """Compare LORD 3 with adaptive methods."""

    print("Online FDR Method Comparison:")
    print("=" * 35)

    # Create method instances
    methods = {
        'LORD 3': LordThree(alpha=0.05, wealth=0.025, reward=0.025),
        'SAFFRON': Saffron(alpha=0.05, wealth=0.025, lambda_=0.5),
        'ADDIS': Addis(alpha=0.05, wealth=0.025, lambda_=0.25, tau=0.5)
    }

    results = {}

    for method_name, method in methods.items():
        decisions = [method.test_one(p) for p in p_values]
        discoveries = sum(decisions)
        discovery_indices = [i+1 for i, d in enumerate(decisions) if d]

        results[method_name] = {
            'decisions': decisions,
            'discoveries': discoveries,
            'indices': discovery_indices
        }

        print(f"{method_name:>8}: {discoveries} discoveries at positions {discovery_indices}")

    return results

# Test with a realistic p-value sequence
realistic_p_values = [0.001, 0.25, 0.02, 0.7, 0.005, 0.9, 0.04, 0.3, 0.008, 0.6]
results = compare_online_methods(realistic_p_values)

from online_fdr.utils.generation import DataGenerator, GaussianLocationModel
import numpy as np

def lord_with_correlation():
    """Test LORD 3 with correlated data."""

    print("LORD 3 with Correlated Test Statistics:")
    print("=" * 42)

    # Generate correlated test statistics (AR(1) process)
    n_tests = 100
    rho = 0.3  # Correlation parameter

    # Start with independent standard normals
    z = np.random.normal(0, 1, n_tests)

    # Apply AR(1) structure: z_t = rho * z_{t-1} + sqrt(1-rho^2) * epsilon_t
    for t in range(1, n_tests):
        z[t] = rho * z[t-1] + np.sqrt(1 - rho**2) * z[t]

    # Add signal to first 20% of tests
    n_alternatives = int(0.2 * n_tests)
    z[:n_alternatives] += 2.0  # Add signal

    # Convert to p-values (two-sided)
    from scipy.stats import norm
    p_values = 2 * (1 - norm.cdf(np.abs(z)))
    true_alternatives = np.zeros(n_tests, dtype=bool)
    true_alternatives[:n_alternatives] = True

    # Apply LORD 3
    lord3 = LordThree(alpha=0.05, wealth=0.025, reward=0.025)

    decisions = [lord3.test_one(p) for p in p_values]

    # Evaluate performance
    true_positives = sum(d and t for d, t in zip(decisions, true_alternatives))
    false_positives = sum(d and not t for d, t in zip(decisions, true_alternatives))
    total_discoveries = true_positives + false_positives

    empirical_fdr = false_positives / max(total_discoveries, 1)
    power = true_positives / n_alternatives

    print(f"Correlation (ρ): {rho}")
    print(f"True alternatives: {n_alternatives}")
    print(f"Total discoveries: {total_discoveries}")
    print(f"True positives: {true_positives}")
    print(f"False positives: {false_positives}")
    print(f"Empirical FDR: {empirical_fdr:.3f}")
    print(f"Power: {power:.3f}")

    return empirical_fdr, power

# Run correlation test
fdr, power = lord_with_correlation()