```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, then multiply by base.
            # If base is an int, base * 2**i is an int, no overflow issue for comparison with cap (int).
            # If base is a float, base * 2**i converts 2**i to float, which can overflow.
            
            # To avoid overflow when base is float:
            # We can check if 2**i is too large such that base * 2**i > cap.
            # Since base > 0, we can compute log2(cap / base) to find the threshold.
            # But using math.log2 requires import. We can't import third-party, but math is standard.
            # However, the problem says "不得导入第三方库", math is standard library, so it's allowed.
            # But let's avoid imports if possible.
            
            # Alternative: iteratively compute and check.
            # For each i, we want min(cap, base * 2**i).
            # If base * 2**i >= cap, then delay = cap.
            # We can detect when base * 2**i >= cap without computing the huge number.
            
            # Let's use a different approach:
            # If base is 0, delay = 0.
            # If base > 0:
            #   We want to know if base * 2**i >= cap.
            #   This is equivalent to 2**i >= cap / base.
            #   If cap == 0, then delay = 0 (since base * 2**i >= 0, min(0, ...) = 0).
            #   If cap > 0 and base > 0:
            #     We can find the smallest i such that base * 2**i >= cap.
            #     For i < that threshold, delay = base * 2**i.
            #     For i >= that threshold, delay = cap.
            
            # But we need to handle float base. Let's just try to compute safely.
            # If base is an int, base * 2**i is int, no overflow.
            # If base is a float, we need to avoid converting huge int to float.
            
            # Let's check if base is int or float.
            if isinstance(base, int):
                # base * 2**i is int, no overflow
                delay = min(cap, base * (2 ** i))
            else:
                # base is float
                # If cap == 0, delay = 0
                if cap == 0:
                    delay = 0
                else:
                    # We need to check if base * 2**i >= cap
                    # If 2**i is too large, base * 2**i will overflow when converting to float.
                    # We can check if 2**i > cap / base.
                    # But cap / base might be float.
                    # Let's compute threshold = cap / base.
                    # If 2**i >= threshold, delay = cap.
                    # Otherwise, delay = base * 2**i.
                    
                    # To avoid overflow, we can check if i is large enough that 2**i > cap / base.
                    # We can compute this by checking if i > log2(cap / base).
                    # But we don't want to import math.
                    
                    # Alternative: iteratively multiply base by 2 and check against cap.
                    # Start with current = base.
                    # For each i, if current >= cap, delay = cap.
                    # Otherwise, delay = current, then current *= 2.
                    # This avoids computing 2**i directly.
                    
                    # Let's use this iterative approach for float base.
                    # But we need to be careful with precision.
                    
                    # Actually, let's just use the iterative approach for all cases to be safe.
                    # Start with current = base.
                    # For i in range(attempts):
                    #   delay = min(cap, current)
                    #   current *= 2
                    # This avoids computing 2**i directly and avoids overflow.
                    
                    # Let's redo the whole function with this approach.
                    pass
        
        # Let's restart with the iterative approach
        pass
    
    # Redo with iterative approach
    result = []
    current = base
    for i in range(attempts):
        delay = min(cap, current)
        result.append(delay)
        current *= 2
    return result
```