```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, compute 2**i as an integer. If base is an integer, base * 2**i is an integer.
            # If base is a float, we need to be careful.
            
            # Let's check if base * 2**i > cap without causing overflow.
            # If base is 0, handled above.
            # If base > 0:
            #   If base * 2**i >= cap, delay = cap
            #   Else delay = base * 2**i
            
            # To avoid overflow when base is float and 2**i is huge:
            # We can check if 2**i > cap / base (if base > 0)
            # But cap / base might be problematic if base is very small.
            
            # Alternative: compute 2**i as int. If base is int, base * 2**i is int, no overflow issue for comparison with cap (int).
            # If base is float, we need to avoid converting huge int to float.
            
            # Let's handle base as float or int.
            # If base is int:
            #   val = base * (2 ** i)
            #   delay = min(cap, val)
            # If base is float:
            #   We need to check if base * 2**i > cap.
            #   If 2**i is too large to convert to float, we can check if base * 2**i > cap by comparing 2**i > cap / base.
            #   But cap / base might be inf or nan if base is 0 (handled) or very small.
            
            # Let's use a safe approach:
            # If base == 0: delay = 0
            # Else:
            #   power = 2 ** i
            #   if isinstance(base, int):
            #       val = base * power
            #       delay = min(cap, val)
            #   else:
            #       # base is float
            #       # Check if power is too large to convert to float
            #       # If base * power > cap, delay = cap
            #       # We can check if power > cap / base
            #       # But cap / base might be problematic.
            #       # Let's try to compute base * power safely.
            #       # If power is huge, base * power will overflow when converted to float.
            #       # So we check if power > cap / base.
            #       # If cap / base is inf, then base * power > cap for any power > 0.
            #       # If cap / base is finite, check if power > cap / base.
            
            # Let's implement a safe comparison:
            # If base == 0: delay = 0
            # Else:
            #   power = 2 ** i
            #   if isinstance(base, int):
            #       val = base * power
            #       delay = min(cap, val)
            #   else:
            #       # base is float
            #       # Check if base * power > cap
            #       # If power is too large, base * power will overflow.
            #       # We can check if power > cap / base.
            #       # But cap / base might be inf or nan.
            #       # Let's handle edge cases.
            #       if cap == 0:
            #           delay = 0
            #       else:
            #           # Check if base * power > cap
            #           # If base * power > cap, delay = cap
            #           # We can check if power > cap / base
            #           # But cap / base might be problematic.
            #           # Let's try to compute base * power safely.
            #           # If power is huge, base * power will overflow.
            #           # So we check if power > cap / base.
            #           # If cap / base is inf, then base * power > cap for any power > 0.
            #           # If cap / base is finite, check if power > cap / base.
            #           try:
            #               threshold = cap / base
            #               if power > threshold:
            #                   delay = cap
            #               else:
            #                   delay = base * power
            #           except (OverflowError, ZeroDivisionError):
            #               delay = cap
            #       # But this might not handle all cases correctly.
            #       # Let's simplify:
            #       # If base * power > cap, delay = cap
            #       # We can check if power > cap / base
            #       # But cap / base might be inf or nan.
            #       # Let's handle it differently.
            #       # If base == 0: delay = 0
            #       # Else:
            #       #   power = 2 ** i
            #       #   if isinstance(base, int):
            #       #       val = base * power
            #       #       delay = min(cap, val)
            #       #   else:
            #       #       # base is float
            #       #       # Check if base * power > cap
            #       #       # If power is too large, base * power will overflow.
            #       #       # We can check if power > cap / base
            #       #       # But cap / base might be problematic.
            #       #       # Let's try to compute base * power safely.
            #       #       # If power is huge, base * power will overflow.
            #       #       # So we check if power > cap / base.
            #       #       # If cap / base is inf, then base * power > cap for any power > 0.
            #       #       # If cap / base is finite, check if power > cap / base.
            #       #       try:
            #       #           threshold = cap / base
            #       #           if power > threshold:
            #       #               delay = cap
            #       #           else:
            #       #               delay = base * power
            #       #       except (OverflowError, ZeroDivisionError):
            #       #           delay = cap
            #       #       # But this might not handle all cases correctly.
            #       #       # Let's simplify:
            #       #       # If base * power > cap, delay = cap
            #       #       # We can check if power > cap / base
            #       #       # But cap / base might be inf or nan.
            #       #       # Let's handle it differently.
            #       #       # If base == 0: delay = 0
            #       #       # Else:
            #       #       #   power = 2 ** i
            #       #       #   if isinstance(base, int):
            #       #       #       val = base * power
            #       #       #       delay = min(cap, val)
            #       #       #   else:
            #       #       #       # base is float
            #       #       #       # Check if base * power > cap
            #       #       #       # If power is too large, base * power will overflow.
            #       #       #       # We can check if power > cap / base
            #       #       #       # But cap / base might be problematic.
            #       #       #       # Let's try to compute base * power safely.
            #       #       #       # If power is huge, base * power will overflow.
            #       #       #       # So we check if power > cap / base.
            #       #      