```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) 
            # will try to convert huge_int to float for comparison, causing OverflowError.
            
            # Strategy: if 2**i is so large that base * 2**i > cap, we can detect this
            # without computing the full product.
            
            # If base == 0, handled above.
            # If cap == 0, delay is 0.
            if cap == 0:
                delay = 0
            else:
                # We need min(cap, base * 2**i)
                # If base * 2**i >= cap, result is cap.
                # Otherwise, result is base * 2**i.
                
                # To avoid overflow, check if 2**i * base > cap.
                # If base is int and 2**i is int, product is int.
                # If base is float, base * 2**i might overflow when converting 2**i to float.
                
                # Let's handle both cases:
                # Case 1: base is int
                # Case 2: base is float
                
                if isinstance(base, int):
                    # base * 2**i is an int. If it's huge, we need to check if it > cap.
                    # cap is a float. Comparing int > float works in Python, but if int is too large,
                    # Python handles it correctly without overflow in comparison? Actually, Python
                    # can compare large ints with floats correctly.
                    # But min(cap, huge_int) will try to convert huge_int to float, which causes OverflowError.
                    # So we need to avoid calling min with a huge int.
                    
                    # Check if base * 2**i > cap
                    # If base * 2**i > cap, result is cap.
                    # We can check: if base * 2**i > cap, but this comparison itself might be fine.
                    # The issue is min() converting the int to float.
                    
                    # So: compute product as int, compare with cap. If product > cap, use cap.
                    # If product <= cap, use product (which is int, but we need float? No, min returns the smaller value.
                    # If product <= cap, product is int, cap is float. min returns product (int).
                    # But the problem says base and cap are non-negative numbers, so they could be floats.
                    # The result should be a float? The problem doesn't specify, but typically delays are floats.
                    
                    # Let's just compute product as int, compare with cap.
                    product = base * (2 ** i)
                    if product > cap:
                        delay = cap
                    else:
                        delay = float(product) if isinstance(cap, float) else product
                else:
                    # base is float
                    # base * 2**i: 2**i is int, converting to float might overflow.
                    # If 2**i is too large, base * 2**i will be inf or overflow.
                    # We need to check if base * 2**i > cap without overflow.
                    
                    # If base == 0, handled above.
                    # If base > 0, and 2**i is huge, base * 2**i > cap (assuming cap is finite).
                    # We can check: if 2**i > cap / base, then base * 2**i > cap.
                    # But cap / base might be problematic if base is very small.
                    
                    # Alternative: if 2**i is so large that it would overflow when converted to float,
                    # then base * 2**i > cap (since cap is finite).
                    # The max float is about 1.8e308. 2**i > 1.8e308 when i > 1024.
                    # So if i > 1024, 2**i as float overflows.
                    
                    # But we need to be careful: if base is very small, base * 2**i might still be <= cap.
                    # E.g., base = 1e-300, i = 1024, 2**1024 ~ 1.8e308, base * 2**1024 ~ 1.8e8, which is fine.
                    
                    # So we need to check if base * 2**i > cap.
                    # If i is large enough that 2**i as float overflows, we need to check if base * 2**i > cap.
                    # If base * 2**i would overflow, it's definitely > cap (since cap is finite).
                    # But if base is very small, base * 2**i might not overflow.
                    
                    # Let's use a safe approach:
                    # If i > 1024, 2**i as float overflows. But base * 2**i as float might not overflow if base is small.
                    # Actually, base * 2**i = base * (2**i). If 2**i > max_float / base, then base * 2**i > max_float, which is inf.
                    # So if base * 2**i > cap, we use cap.
                    
                    # We can check: if base * 2**i > cap.
                    # To avoid overflow, check if 2**i > cap / base.
                    # But cap / base might be inf if base is very small.
                    
                    # Simpler: if i > 1024, 2**i as int is huge. base * 2**i as float will overflow if base > 0.
                    # So if i > 1024 and base > 0, base * 2**i > cap (since cap is finite).
                    # But this is not always true: if base is extremely small, base * 2**i might be <= cap.
                    
                    # Let's just try to compute base * 2**i safely.
                    # If i <= 1024, 2**i as float is fine.
                    # If i > 1024, 2**i as float overflows. But base * 2**i might still be computable if base is small.
                    
                    # Actually, in Python, float * int where int is huge will try to convert int to float, causing OverflowError.
                    # So we need to avoid that.
                    
                    # Check if 2**i > cap / base. If so, base * 2**i > cap.
                    # But cap / base might be problematic.
                    
                    # Let's use: if base > 0 and i > 1024, then 2**i as float overflows.
                    # But base * 2**i as float: if base is small enough, it might not overflow.
                    # E.g., base = 1e-300, i = 1024, 2**1024 ~ 1.8e308, base * 2**1024 ~ 1.8e8, fine.
                    # base = 1e-300, i = 1025, 2**1025 ~ 3.6e308, base * 2**1025 ~ 3.6e8, fine.
                    # base = 1e-300, i = 1024 + 300, 2**i ~ 1.8e308 * 2**300 ~ 1.8e308 * 1.6e90 ~ 2.9e398, base * 2**i ~ 2.9e98, fine.
                    
                    # So for base = 1e-300, i can be up to about 1024 + 3