```python
def retry_delays(attempts, base, cap):
    if isinstance(attempts, bool) or not isinstance(attempts, int):
        raise TypeError("attempts must be a non-negative integer")
    if attempts < 0:
        raise ValueError("attempts must be non-negative")
    if base < 0:
        raise ValueError("base must be non-negative")
    if cap < 0:
        raise ValueError("cap must be non-negative")
    
    result = []
    for i in range(attempts):
        # Compute base * 2**i without converting huge int to float
        # If base is 0, delay is 0
        if base == 0:
            delay = 0
        else:
            # Check if base * 2**i exceeds cap
            # We need to compare base * 2**i with cap
            # Since cap is a float, we need to handle carefully
            # If 2**i is too large, base * 2**i will definitely exceed cap (if cap is finite)
            # But we need to avoid OverflowError when converting int to float
            
            # Approach: if base * 2**i > cap, use cap
            # To check this without overflow:
            # If base == 0, handled above
            # If cap == 0, delay is 0
            if cap == 0:
                delay = 0
            else:
                # Check if base * 2**i > cap
                # We can compute 2**i as int, then multiply by base
                # But base might be float, so base * 2**i could overflow when converting 2**i to float
                
                # Better approach: compare using logarithms or check if 2**i is too large
                # If base * 2**i > cap, then delay = cap
                # We need to determine if base * 2**i > cap without overflow
                
                # If base is an int, base * 2**i is an int, compare with cap (float)
                # If base is a float, we need to be careful
                
                # Let's use a safe comparison:
                # If 2**i is so large that base * 2**i > cap, use cap
                # We can check: if base > 0 and cap > 0, then 2**i > cap / base means base * 2**i > cap
                # But cap / base might be problematic if base is very small
                
                # Alternative: compute step by step, but that's O(attempts)
                # Since attempts can be 10000, we need an efficient approach
                
                # Key insight: once base * 2**i >= cap, all subsequent values are cap
                # So we can find the first i where base * 2**i >= cap, then fill the rest with cap
                
                # But we need to handle the case where base * 2**i overflows when converting to float
                
                # Let's think differently:
                # If base is 0, delay = 0
                # If cap is 0, delay = 0
                # Otherwise, for each i, compute min(cap, base * 2**i)
                # The issue is when 2**i is huge and base * 2**i needs to be converted to float
                
                # Safe approach: if base * 2**i would overflow when converted to float, it's definitely > cap (assuming cap is finite)
                # So we can check if 2**i is too large for float conversion
                
                # Python's float max is about 1.8e308
                # If base * 2**i > cap, use cap
                # If base * 2**i <= cap, compute it
                
                # To avoid overflow, we can check if 2**i > cap / base (when base > 0)
                # But cap / base might be inf or very large
                
                # Let's use a different approach:
                # For each i, if base * 2**i > cap, use cap
                # We can check this by: if base > 0 and cap > 0, then 2**i > cap / base
                # But if base is very small, cap / base could be huge
                
                # Actually, the simplest safe approach:
                # If base == 0 or cap == 0, delay = 0
                # Otherwise, compute base * 2**i carefully
                # If 2**i is too large to convert to float, then base * 2**i > cap (since cap is finite)
                # So use