```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, result is 0
        if base == 0:
            value = 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, value = 0
            if cap == 0:
                value = 0
            else:
                # Check if base * 2**i > cap
                # We can do this by checking if 2**i > cap / base
                # But cap / base might be problematic if base is very small
                # Alternative: compute step by step or use logarithms?
                # Simpler: if i is large enough that 2**i * base > cap, use cap
                # We can check: if base * 2**i > cap
                # To avoid overflow, we can check if 2**i > cap / base
                # But cap / base could be inf or cause issues
                
                # Let's use a different approach:
                # If base * 2**i would overflow when converted to float, it's definitely > cap
                # So we can check if 2**i is so large that base * 2**i > cap
                # We can do: if i >= some threshold, use cap
                # Or: compute base * 2**i as int, then compare with cap
                
                # The issue is that base * 2**i as int can be huge, and converting to float causes OverflowError
                # So we need to avoid converting huge ints to float
                
                # Strategy: 
                # If base * 2**i > cap, return cap
                # To check this without overflow:
                # If base == 0, handled
                # If cap == 0, handled
                # Otherwise, check if 2**i > cap / base
                # cap / base is a float division, which is fine
                # But if base is very small, cap / base could be very large
                # If 2**i > cap / base, then base * 2**i > cap
                
                # However, cap / base could be inf if base is very small
                # Let's handle this:
                # If base > 0 and cap > 0:
                #   threshold = cap / base
                #   if 2**i > threshold, use cap
                #   else, compute base * 2**i as float (which won't overflow because 2**i <= threshold)
                
                # But 2**i as int can be huge, and comparing with float threshold is fine
                # The problem is when we compute base * 2**i as int and then convert to float
                
                # Let's restructure:
                # If base * 2**i > cap, use cap
                # Check: is 2**i > cap / base?
                # If yes, use cap
                # If no, compute base * 2**i as float safely (since 2**i <= cap/base, the product won't overflow)
                
                threshold = cap / base
                if 2 ** i > threshold:
                    value = cap
                else:
                    value = base * (2 ** i)
        
        result.append(value)
    return result
```