```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 causing overflow by checking if 2**i exceeds cap/base
        # If base == 0, then base * 2**i == 0, so min(cap, 0) = 0
        if base == 0:
            result.append(0.0)
            continue
        # Check if 2**i * base > cap, i.e., 2**i > cap / base
        # To avoid overflow, we can check if i is large enough that 2**i * base > cap
        # Since cap and base are non-negative, if cap == 0, then min(cap, ...) = 0
        if cap == 0:
            result.append(0.0)
            continue
        # We need to compute min(cap, base * 2**i)
        # If base * 2**i > cap, then result is cap
        # Otherwise, result is base * 2**i
        # To avoid overflow, check if 2**i > cap / base
        # cap / base could be a float, but we can use integer comparison
        # If i is large, 2**i can be huge. We can check if i >= some threshold.
        # Alternatively, compute 2**i as int, then multiply by base (float), but if 2**i is too large, it overflows.
        # So we should check if 2**i * base > cap without computing 2**i * base directly.
        # We can check if i is large enough that 2**i > cap / base.
        # cap / base is a float. If cap / base is very large, we need to be careful.
        # Let's use: if i >= 1024, then 2**i is huge, and base * 2**i will definitely exceed cap (unless base is 0, already handled).
        # But we need a more precise check.
        # We can compute 2**i as int, but if i is large, 2**i is a big int, which is fine in Python.
        # The problem is converting to float. So we should avoid converting to float if possible.
        # Instead, we can check if base * 2**i > cap by comparing 2**i > cap / base.
        # cap / base is a float. If cap / base is inf, then base * 2**i > cap for all i.
        # If cap / base is finite, we can check if 2**i > cap / base.
        # But 2**i as int can be compared to cap / base as float? That might cause issues.
        # Better approach: if i is large enough that 2**i * base > cap, return cap.
        # We can determine the threshold: find the smallest i such that base * 2**i > cap.
        # If base == 0, handled. If cap == 0, handled.
        # Otherwise, compute threshold = log2(cap / base). If i >= threshold, then base * 2**i >= cap.
        # But we don't want to use math.log2 (no third-party, but math is standard library).
        # Actually, we can avoid math by checking if 2**i > cap / base.
        # Let's compute cap / base as float. If cap / base is inf, then for all i, base * 2**i > cap (since base > 0).
        # If cap / base is finite, we can check if 2**i > cap / base.
        # But 2**i as int can be huge. Comparing int to float is fine in Python.
        # However, if 2**i is too large to convert to float, we get OverflowError.
        # So we should avoid converting 2**i to float. Instead, we can check if i is large enough.
        # Let's find the maximum i such that base * 2**i <= cap.
        # If base * 2**i <= cap, then 2