```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, i.e., 2**i > cap / base
        # To avoid computing huge 2**i, we can check if i is large enough that 2**i * base > cap
        # Since cap and base are non-negative, if cap == 0, then min(cap, ...) = 0
        if cap == 0:
            result.append(0.0)
            continue
        
        # We need min(cap, base * 2**i)
        # If base * 2**i >= cap, then result is cap
        # Otherwise, result is base * 2**i
        
        # To avoid overflow, check if 2**i * base > cap
        # This is equivalent to 2**i > cap / base
        # We can compute this safely by checking if i is large enough
        
        # If i is large, 2**i can be huge. We need to check if base * 2**i > cap
        # Let's compute 2**i only when it won't overflow
        
        # A safe approach: if i is large enough that 2**i * base > cap, use cap
        # We can determine this by checking if i >= some threshold
        
        # The threshold is when 2**i > cap / base
        # i > log2(cap / base)
        
        # But we can avoid floating point issues by using integer comparison
        # If base * 2**i > cap, then 2**i > cap / base
        
        # Let's compute 2**i as an integer and compare with cap / base
        # But cap / base might not be an integer
        
        # Alternative: compute base * 2**i step by step, but stop when it exceeds cap
        
        # Actually, let's just compute 2**i as an integer, then multiply by base
        # If 2**i is too large to convert to float, we know base * 2**i > cap (since cap is finite)
        
        # So we can check: if 2**i > cap / base, then result = cap
        # But cap / base might be a float, and 2**i is an int
        
        # Let's use a different approach: compute the value iteratively
        # Start with val = base, then double it each time, but cap at cap
        
        # This avoids computing huge powers
        
        pass
    
    # Let me redo this properly
    result = []
    for i in range(attempts):
        if base == 0 or cap == 0:
            result.append(0.0)
            continue
        
        # Compute base * 2**i safely
        # If 2**i is too large, then base * 2**i > cap, so result = cap
        # We can check if i is large enough that 2**i * base > cap
        
        # Compute 2**i as an integer
        power = 1 << i  # 2**i as integer
        
        # Check if power * base > cap
        # Since base and cap are floats, we need to be careful
        # If power is very large, power * base might overflow
        
        # Instead, check if power > cap / base
        # cap / base is a float, power is an int
        
        # If cap / base is finite, and power > cap / base, then base * power > cap
        
        # But cap / base could be very large or very small
        
        # Let's use a threshold approach
        # If i is large enough that 2**i * base > cap, use cap
        
        # We can compute this by checking if i >= log2(cap / base)
        # But log2 might have precision issues
        
        # Alternative: compute iteratively
        val = base
        for j in range(i):
            val *= 2
            if val > cap:
                val = cap
                break
        
        result.append(val)
    
    return result
```