```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 causing overflow by checking if 2**i would exceed cap/base
        # If base == 0, then base * 2**i == 0, so min(cap, 0) = 0
        if base == 0:
            result.append(0.0)
            continue
        
        # Check if 2**i * base > cap, in which case we use cap
        # To avoid overflow, we can check if 2**i > cap / base
        # But cap / base might be problematic if base is very small.
        # Instead, we can compute step by step or use logarithms.
        # A safer approach: if 2**i * base > cap, use cap.
        # We can check if i is large enough that 2**i * base > cap.
        # Since base and cap are non-negative, and base > 0 here:
        # 2**i * base > cap  <=>  2**i > cap / base
        # We can compute cap / base as a float, but if base is very small, cap/base could be huge.
        # Alternatively, we can use logarithms: i * log(2) > log(cap / base)
        # But log(cap/base) might have issues if cap/base is very large or small.
        
        # Simpler approach: compute 2**i as an integer, but if it's too large, we know the result is cap.
        # We can check if 2**i * base > cap by comparing 2**i > cap / base.
        # To avoid overflow in 2**i, we can check if i is large enough.
        # The maximum i where 2**i * base <= cap is when 2**i <= cap / base.
        # If cap / base is very large, 2**i could overflow.
        
        # Let's use a different approach: compute the value iteratively to avoid huge powers.
        # Start with current = base, and for each step, multiply by 2, but cap at cap.
        # This avoids computing 2**i directly.
        
        # Actually, let's just compute iteratively:
        # value = base * 2**i, but we can compute it as base * (2**i)
        # To avoid overflow, we can check if 2**i * base > cap before computing.
        
        # Use logarithm to check: if i * log(2) + log(base) > log(cap), then result is cap.
        # But log(base) might be -inf if base is 0, but we already handled base == 0.
        # If base > 0 and cap > 0, we can use logs.
        # If cap == 0, then min(cap, ...) = 0 for all i.
        
        if cap == 0:
            result.append(0.0)
            continue
        
        # Check if base * 2**i > cap using logarithms to avoid overflow
        import math
        # log(base * 2**i) = log(base) + i * log(2)
        # log(cap) = log(cap)
        # If log(base) + i * log(2) > log(cap), then base * 2**i > cap
        
        # But we need to be careful with floating point precision.
        # Let's compute log_base = math.log(base) if base > 0
        # log_cap = math.log(cap) if cap > 0
        
        # Since base > 0 and cap > 0 here:
        log_base = math.log(base)
        log_cap = math.log(cap)
        log_2 = math.log(2)
        
        if log_base + i * log_2 > log_cap:
            result.append(cap)
        else:
            # Compute base * 2**i safely
            # 2**i might still be large, but if log_base + i*log_2 <= log_cap, then base*2**i <= cap
            # So 2**i <= cap / base, which is finite.
            # We can compute 2**i as an integer, but it might be large.
            # However, since base*2**i <= cap, and cap is a float, 2**i <= cap/base.
            # If cap/base is very large, 2**i could still be large but within float range.
            # Let's compute it as float: base * (2.0 ** i)
            # 2.0 ** i for large i could overflow float.
            # But if log_base + i*log_2 <= log_cap, then base * 2**i <= cap, so 2**i <= cap/base.
            # If cap/base is within float range, 2**i is within float range.
            # But 2**i as an integer could be huge, but as a float, 2.0**i could overflow.
            # Let's compute value = base * (2.0 ** i)
            # If 2.0**i overflows, we'd get inf, but we already checked that base*2**i <= cap, so it shouldn't overflow.
            # Actually, 2.0**i for i up to ~1023 is fine for float64. For i > 1023, 2.0**i overflows.
            # But if log_base + i*log_2 <= log_cap, then i*log_2 <= log_cap - log_base = log(cap/base).
            # So i <= log(cap/base)/log(2). If cap/base is within float range, this i is bounded.
            # So 2.0**i should be within float range.
            value = base * (2.0 ** i)
            result.append(value)
    
    return result
```