```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.0
        else:
            # Check if base * 2**i exceeds cap
            # We can compare using integer arithmetic if base is an integer,
            # but base can be a float. To avoid overflow, we check if 2**i is
            # so large that base * 2**i > cap.
            # Since cap is non-negative, if cap == 0, delay is 0.
            if cap == 0:
                delay = 0.0
            else:
                # If base * 2**i > cap, use cap.
                # To avoid computing huge 2**i as float, we can check:
                # 2**i > cap / base (if base > 0)
                # But cap/base might be float. Alternatively, we can compute
                # the threshold i where base * 2**i >= cap.
                # For large i, 2**i as int is fine, but converting to float
                # for multiplication causes overflow.
                # Instead, we can check if 2**i > cap / base using integer
                # comparison when possible, or use logarithms.
                # Simpler: if i is large enough that 2**i > cap / base,
                # then delay = cap.
                # We can compute threshold = cap / base if base > 0.
                # But to avoid float issues, let's use a different approach:
                # If base * 2**i would overflow, it's definitely > cap (since cap is finite).
                # So we can check if 2**i > cap / base.
                # However, cap / base could be problematic if base is very small.
                # Let's use: if i >= some threshold, delay = cap.
                # Threshold: smallest i such that base * 2**i >= cap.
                # If base == 0, handled above.
                # If cap == 0, handled above.
                # For base > 0 and cap > 0:
                # We need to check if base * 2**i > cap.
                # This is equivalent to 2**i > cap / base.
                # To avoid float overflow in 2**i, we can check if i is large
                # enough that 2**i as int > cap / base.
                # But cap / base is a float. Let's compute it once.
                # Actually, we can just check if 2**i > cap / base by comparing
                # int(2**i) > cap / base. But 2**i as int is fine for large i,
                # but cap / base is float. Comparing int to float is fine.
                # However, 2**i for i=10000 is a huge int, but Python handles
                # big ints. The issue is converting to float for multiplication.
                # So we can do: if 2**i > cap / base, then delay = cap.
                # But cap / base might be inf if base is very small.
                # Let's handle it carefully.
                # Alternative: compute delay = base * 2**i only if 2**i is not
                # too large. We can check if i > 1024 (since 2**1024 is near
                # float max). But base could be small.
                # Better approach: use logarithms to find threshold.
                # threshold_i = ceil(log2(cap / base)) if base > 0.
                # If i >= threshold_i, delay = cap.
                # Otherwise, compute base * 2**i safely.
                import math
                if base > 0:
                    # Find smallest i such that base * 2**i >= cap
                    # i >= log2(cap / base)
                    if cap > 0:
                        threshold = math.ceil(math.log2(cap