parameters: (c, e, p)
return_statement: return _div_nearest(log_tenpower+log_d, 100)
docstring: 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.
docstring_summary: 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.
docstring_tokens: 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 .
function: 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)
function_tokens: 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 )