def pow_complexity(num, exp):
    """Estimate the worst case time :func:`pow` takes to calculate.

    :param num: base
    :type num: int or float
    :param exp: exponent
    :type exp: int or float

    This function is based on experimental data from the time it takes to
    calculate ``num**exp`` in 32-bit CPython 2.7.6 on an Intel Core i7-2670QM
    laptop running Windows.

    It tries to implement this surface: x=exp, y=num

    +----+------+------+------+------+-------+-------+-------+-------+-------+
    |    |  1e5 |  2e5 |  3e5 |  4e5 |  5e5  |  6e5  |  7e5  |  8e5  |  9e5  |
    +====+======+======+======+======+=======+=======+=======+=======+=======+
    | e1 | 0.03 | 0.09 | 0.16 | 0.25 |  0.35 |  0.46 |  0.60 |  0.73 |  0.88 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e2 | 0.08 | 0.24 | 0.46 | 0.73 |  1.03 |  1.40 |  1.80 |  2.21 |  2.63 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e3 | 0.15 | 0.46 | 0.87 | 1.39 |  1.99 |  2.63 |  3.35 |  4.18 |  5.15 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e4 | 0.24 | 0.73 | 1.39 | 2.20 |  3.11 |  4.18 |  5.39 |  6.59 |  7.88 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e5 | 0.34 | 1.03 | 2.00 | 3.12 |  4.48 |  5.97 |  7.56 |  9.37 | 11.34 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e6 | 0.46 | 1.39 | 2.62 | 4.16 |  5.97 |  7.86 | 10.09 | 12.56 | 15.39 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e7 | 0.60 | 1.79 | 3.34 | 5.39 |  7.60 | 10.16 | 13.00 | 16.23 | 19.44 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e8 | 0.73 | 2.20 | 4.18 | 6.60 |  9.37 | 12.60 | 16.26 | 19.83 | 23.70 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+
    | e9 | 0.87 | 2.62 | 5.15 | 7.93 | 11.34 | 15.44 | 19.40 | 23.66 | 28.58 |
    +----+------+------+------+------+-------+-------+-------+-------+-------+

    For powers of 2 it tries to implement this surface:

    +---+------+------+------+------+------+------+------+------+------+
    |   |  1e7 |  2e7 |  3e7 |  4e7 |  5e7 |  6e7 |  7e7 |  8e7 |  9e7 |
    +===+======+======+======+======+======+======+======+======+======+
    | 1 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
    +---+------+------+------+------+------+------+------+------+------+
    | 2 | 0.21 | 0.44 | 0.71 | 0.92 | 1.20 | 1.49 | 1.66 | 1.95 | 2.23 |
    +---+------+------+------+------+------+------+------+------+------+
    | 4 | 0.43 | 0.91 | 1.49 | 1.96 | 2.50 | 3.13 | 3.54 | 4.10 | 4.77 |
    +---+------+------+------+------+------+------+------+------+------+
    | 8 | 0.70 | 1.50 | 2.24 | 3.16 | 3.83 | 4.66 | 5.58 | 6.56 | 7.67 |
    +---+------+------+------+------+------+------+------+------+------+

    The function numbers were selected by starting with the theoretical
    complexity of ``exp * log2(num)**2`` and fiddling with the exponents
    until it more or less matched with the table.

    Because this function is based on a limited set of data it might not give
    accurate results outside these boundaries. The results derived from large
    ``num`` and ``exp`` were quite accurate for small ``num`` and very large
    ``exp`` though, except when ``num`` was a power of 2.
    """
    if num in (0, 1) or exp in (0, 1):
        return 0
    elif num & num - 1 == 0:
        return exp ** 1.092 * num.bit_length() ** 1.65 / 623212911.121
    else:
        return exp ** 1.59 * num.bit_length() ** 1.73 / 36864057619.3
