```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
            
            # Approach: if base * 2**i > cap, use cap
            # We can check if 2**i > cap / base (when base > 0)
            # But cap / base might be problematic if base is very small
            
            # Alternative: compute step by step, checking overflow
            # Or: if i is large enough that 2**i > cap / base, then min(cap, base*2**i) = cap
            
            # Let's think: base * 2**i vs cap
            # If base == 0, handled above
            # If base > 0:
            #   base * 2**i > cap  <=>  2**i > cap / base
            #   So if 2**i > cap / base, result is cap
            
            # But cap / base could be very large or very small
            # We need to avoid OverflowError
            
            # Better approach: compute base * 2**i as float only when it's safe
            # If 2**i is too large to convert to float, then base * 2**i > cap (assuming cap is finite float)
            # So we can check: if i is large enough that 2**i > some threshold, use cap
            
            # The maximum float is about 1.8e308
            # 2**i > 1.8e308 when i > 1024 approximately
            # But base * 2**i could overflow even earlier if base is large
            
            # Let's use a different approach:
            # Compute value = base * 2**i
            # If base is an int, base * 2**i is an int. Converting to float may overflow.
            # If base is a float, base * 2**i: 2**i is int, multiplying float by huge int may overflow.
            
            # Strategy: 
            # - If base == 0: delay = 0
            # - Otherwise, try to compute base * 2**i
            #   If it would overflow, use cap
            
            # We can check: if 2**i > cap / base (for base > 0), then result = cap
            # But cap / base might not be representable
            
            # Simpler: iterate and check if base * 2**i > cap
            # For large i, 2**i grows exponentially. Once base * 2**i > cap, all subsequent values are cap.
            # We can find the threshold i where base * 2**i > cap
            
            # Let's compute iteratively to avoid huge numbers:
            # Start with val = base
            # For each i, val = base * 2**i
            # But we can compute val incrementally: val *= 2 each step
            
            # Actually, let's just compute val = base * 2**i but check for overflow
            
            # Use try/except or check magnitude
            
            # Let me reconsider: the problem says "不发生浮点溢出" (no float overflow)
            # So we need to handle cases where base * 2**i would overflow float
            
            # Approach: 
            # val = base
            # for i in range(attempts):
            #   delay = min(cap, val)
            #   val *= 2
            #   But val might overflow
            
            # Better: check if val > cap before multiplying
            # If val > cap, then for all subsequent i, delay = cap
            
            # Let's do:
            # val = base
            # for i in range(attempts):
            #   if val > cap:
            #       delay = cap
            #   else:
            #       delay = val
            #   val *= 2
            #   But val *= 2 might overflow
            
            # Hmm, but val is base * 2**i. If base is float, val is float.
            # If base is int, val is int.
            
            # Let's handle both cases:
            # If base is int: base * 2**i is int. min(cap, int) where cap is float.
            #   Converting huge int to float may overflow.
            #   So we need to check if base * 2**i > cap without converting to float.
            #   If base * 2**i > cap, use cap.
            #   How to check? If base * 2**i > cap, and cap is float...
            #   We can compare int with float: Python handles this correctly for reasonable sizes.
            #   But for huge ints, comparison with float works in Python 3.
            
            # Actually, in Python 3, comparing int with float works correctly even for huge ints.
            # So base * 2**i > cap should work fine.
            # The issue is when we try to convert base * 2**i to float for min().
            # min(cap, base * 2**i) - if base * 2**i is a huge int, min() tries to convert it to float, causing OverflowError.
            
            # So we need to avoid converting huge int to float.
            # Solution: if base * 2**i > cap, return cap directly.
            # Otherwise, compute min(cap, base * 2**i) safely.
            
            # Check: if base * 2**i > cap, use cap.
            # This comparison works in Python 3 for int vs float.
            
            # But what if base * 2**i is not > cap but is huge? Then min(cap, base*2**i) = base*2**i, which needs to be converted to float.
            # If base*2**i is huge but <= cap, then cap must also be huge, which is unlikely for float.
            # Actually, if base*2**i <= cap and cap is a float, then base*2**i must be representable as float.
            # So the only issue is when base*2**i > cap, in which case we return cap.
            
            # So the fix is:
            # val = base * 2**i
            # if val > cap: delay = cap
            # else: delay = float(val) if isinstance(val, int) else val
            
            # Wait, but val = base * 2**i. If base is int, val is int. If base is float, val is float.
            # If val is int and val > cap, we return cap (float).
            # If val is int and val <= cap, we need to return val as float? Or as int?
            # The problem says base and cap are non-negative numbers. They could be int or float.
            # The result should be min(cap, base * 2**i).
            # If base is int and cap is float, min(cap, int) returns float in Python.
            # But converting huge int to float causes OverflowError.
            
            # So: if val > cap, return cap.
            # If val <= cap, return val (which is safe to convert to float since val <= cap and cap is float).
            
            # Let's implement this:
            val = base * (2 ** i)
            if val > cap:
                delay = cap
            else:
                delay = val
            
            result.append(delay)
    
    return result
```