```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
            
            # If base is an int, base * 2**i is an int. If it's huge, min(cap, huge_int) 
            # would try to convert huge_int to float for comparison, causing OverflowError.
            # So we need to check if base * 2**i > cap without converting to float.
            
            # If base is a float, base * 2**i could overflow float.
            # We need to handle this carefully.
            
            # Strategy: if 2**i is so large that base * 2**i > cap, return cap.
            # We can check: if base > 0 and cap > 0, then base * 2**i > cap iff 2**i > cap / base.
            # But cap / base might be problematic if base is 0 (already handled).
            
            # Let's think differently. We want min(cap, base * 2**i).
            # If base * 2**i >= cap, return cap. Otherwise return base * 2**i.
            
            # To avoid overflow, we can check if 2**i > cap / base (when base > 0).
            # But cap / base is a float division. If base is very small, cap/base could be huge.
            # Alternatively, we can compute step by step.
            
            # Simpler approach: compute power = 2**i as int. Then compute base * power.
            # If base is int, base * power is int. If this int is too large to convert to float,
            # we know it's > cap (assuming cap is a reasonable float). But cap could be inf?
            # The problem says cap is non-negative, so cap could be inf.
            
            # Let's handle: if base is int and power is int, base * power is int.
            # If base * power > cap, return cap. But comparing int to float cap:
            # If cap is inf, then base * power < inf always (for finite int), so return base * power.
            # If cap is finite float, and base * power is a huge int, comparing int to float
            # will try to convert int to float, causing OverflowError.
            
            # So we need to avoid that comparison. We can check if base * power > cap
            # by checking if power > cap / base (when base > 0).
            # cap / base is float. If base is int, cap / base is float division.
            # If cap / base is inf, then power > inf is false, so base * power <= cap.
            # If cap / base is finite, and power > cap / base, then base * power > cap.
            
            # But cap / base could overflow if base is very small. Let's handle base == 0 separately.
            
            if base == 0:
                delay = 0
            else:
                # Check if base * 2**i > cap
                # If cap is inf, base * 2**i is always <= inf (for finite values), so return base * 2**i
                if cap == float('inf'):
                    delay = base * (2 ** i)
                else:
                    # We need to check if base * 2**i > cap without overflow
                    # If base is int, 2**i is int, base * 2**i is int.
                    # If base is float, base * 2**i could overflow float.
                    
                    # Let's use