(c, e, p)
return _div_nearest(log_tenpower+log_d, 100)
Given integers c, e and p with c > 0, p >= 0, compute an integer
    approximation to 10**p * log10(c*10**e), with an absolute error of
    at most 1.  Assumes that c*10**e is not exactly 1.
Given integers c, e and p with c > 0, p >= 0, compute an integer
    approximation to 10**p * log10(c*10**e), with an absolute error of
    at most 1.  Assumes that c*10**e is not exactly 1.
Given integers c e and p with c > 0 p > = 0 compute an integer approximation to 10 ** p * log10 ( c * 10 ** e ) with an absolute error of at most 1 . Assumes that c * 10 ** e is not exactly 1 .
def _dlog10(c, e, p):
    """Given integers c, e and p with c > 0, p >= 0, compute an integer
    approximation to 10**p * log10(c*10**e), with an absolute error of
    at most 1.  Assumes that c*10**e is not exactly 1."""

    # increase precision by 2; compensate for this by dividing
    # final result by 100
    p += 2

    # write c*10**e as d*10**f with either:
    #   f >= 0 and 1 <= d <= 10, or
    #   f <= 0 and 0.1 <= d <= 1.
    # Thus for c*10**e close to 1, f = 0
    l = len(str(c))
    f = e+l - (e+l >= 1)

    if p > 0:
        M = 10**p
        k = e+p-f
        if k >= 0:
            c *= 10**k
        else:
            c = _div_nearest(c, 10**-k)

        log_d = _ilog(c, M) # error < 5 + 22 = 27
        log_10 = _log10_digits(p) # error < 1
        log_d = _div_nearest(log_d*M, log_10)
        log_tenpower = f*M # exact
    else:
        log_d = 0  # error < 2.31
        log_tenpower = _div_nearest(f, 10**-p) # error < 0.5

    return _div_nearest(log_tenpower+log_d, 100)
def _dlog10 ( c , e , p ) : # increase precision by 2; compensate for this by dividing # final result by 100 p += 2 # write c*10**e as d*10**f with either: #   f >= 0 and 1 <= d <= 10, or #   f <= 0 and 0.1 <= d <= 1. # Thus for c*10**e close to 1, f = 0 l = len ( str ( c ) ) f = e + l - ( e + l >= 1 ) if p > 0 : M = 10 ** p k = e + p - f if k >= 0 : c *= 10 ** k else : c = _div_nearest ( c , 10 ** - k ) log_d = _ilog ( c , M ) # error < 5 + 22 = 27 log_10 = _log10_digits ( p ) # error < 1 log_d = _div_nearest ( log_d * M , log_10 ) log_tenpower = f * M # exact else : log_d = 0 # error < 2.31 log_tenpower = _div_nearest ( f , 10 ** - p ) # error < 0.5 return _div_nearest ( log_tenpower + log_d , 100 )