```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 carefully to avoid overflow
        # If base is 0, delay is 0
        if base == 0:
            delay = 0
        else:
            # Check if base * 2**i would exceed cap
            # We can compare without computing the full power if it's too large
            # Since cap is non-negative, if base * 2**i >= cap, we use cap
            # To avoid overflow, we can check if 2**i is so large that base * 2**i > cap
            # But we need to handle float base and int cap or vice versa
            
            # Let's handle the case where base * 2**i might overflow
            # If base is a float, 2**i can be huge. We need to avoid converting huge int to float.
            
            # Strategy: if base == 0, delay = 0
            # Otherwise, we want min(cap, base * 2**i)
            # If base * 2**i >= cap, return cap
            # We can check if 2**i >= cap / base (if base > 0)
            # But cap / base might be problematic if base is very small.
            
            # Alternative: compute step by step or use logarithms? No, simpler:
            # If base is 0, delay = 0.
            # If base > 0, we can check if 2**i is large enough that base * 2**i >= cap.
            # Since cap is non-negative, if cap == 0, delay = 0.
            # If cap > 0 and base > 0:
            #   We want to know if base * 2**i >= cap.
            #   This is equivalent to 2**i >= cap / base.
            #   If cap / base is very large, 2**i might overflow when converted to float.
            #   But we can compare using integers if cap and base are integers? Not necessarily.
            
            # Let's think differently. The problem says base and cap are non-negative numbers.
            # They could be floats or ints.
            # We need to avoid OverflowError when converting a huge int (2**i) to float.
            
            # If base is 0, delay = 0.
            # If base > 0:
            #   If cap == 0, delay = 0.
            #   If cap > 0:
            #     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 is so large that base * 2**i > cap.
            #     Since base > 0 and cap > 0, we can compute threshold = cap / base.
            #     If 2**i >= threshold, then base * 2**i >= cap, so return cap.
            #     But threshold might be a float, and 2**i is an int. Comparing int to float is fine unless the int is too large for float.
            #     If 2**i is too large to convert to float, then it's definitely >= threshold (since threshold is finite).
            #     So if 2**i > some large value, we can just return cap.
            #     
            #     How to check if 2**i is too large for float? Float max is about 1.8e308.
            #     2**i > 1.8e308 means i > log2(1.8e308) ≈ 1024.
            #     So if i > 1024, 2**i is too large for float.
            #     In that case, if base > 0 and cap > 0, base * 2**i will definitely be >= cap (since cap is finite), so return cap.
            #     If cap == 0