parameters: (c, e, p)
return_statement: return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3
docstring: Compute an approximation to exp(c*10**e), with p decimal places of
      precision.
  
      Returns integers d, f such that:
  
        10**(p-1) <= d <= 10**p, and
        (d-1)*10**f < exp(c*10**e) < (d+1)*10**f
  
      In other words, d*10**f is an approximation to exp(c*10**e) with p
      digits of precision, and with an error in d of at most 1.  This is
      almost, but not quite, the same as the error being < 1ulp: when d
      = 10**(p-1) the error could be up to 10 ulp.
docstring_summary: Compute an approximation to exp(c*10**e), with p decimal places of
      precision.
docstring_tokens: Compute an approximation to exp ( c * 10 ** e ) with p decimal places of precision .
function: def _dexp(c, e, p):
      """Compute an approximation to exp(c*10**e), with p decimal places of
      precision.
  
      Returns integers d, f such that:
  
        10**(p-1) <= d <= 10**p, and
        (d-1)*10**f < exp(c*10**e) < (d+1)*10**f
  
      In other words, d*10**f is an approximation to exp(c*10**e) with p
      digits of precision, and with an error in d of at most 1.  This is
      almost, but not quite, the same as the error being < 1ulp: when d
      = 10**(p-1) the error could be up to 10 ulp."""
  
      # we'll call iexp with M = 10**(p+2), giving p+3 digits of precision
      p += 2
  
      # compute log(10) with extra precision = adjusted exponent of c*10**e
      extra = max(0, e + len(str(c)) - 1)
      q = p + extra
  
      # compute quotient c*10**e/(log(10)) = c*10**(e+q)/(log(10)*10**q),
      # rounding down
      shift = e+q
      if shift >= 0:
          cshift = c*10**shift
      else:
          cshift = c//10**-shift
      quot, rem = divmod(cshift, _log10_digits(q))
  
      # reduce remainder back to original precision
      rem = _div_nearest(rem, 10**extra)
  
      # error in result of _iexp < 120;  error after division < 0.62
      return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3
function_tokens: def _dexp ( c , e , p ) : # we'll call iexp with M = 10**(p+2), giving p+3 digits of precision p += 2 # compute log(10) with extra precision = adjusted exponent of c*10**e extra = max ( 0 , e + len ( str ( c ) ) - 1 ) q = p + extra # compute quotient c*10**e/(log(10)) = c*10**(e+q)/(log(10)*10**q), # rounding down shift = e + q if shift >= 0 : cshift = c * 10 ** shift else : cshift = c // 10 ** - shift quot , rem = divmod ( cshift , _log10_digits ( q ) ) # reduce remainder back to original precision rem = _div_nearest ( rem , 10 ** extra ) # error in result of _iexp < 120;  error after division < 0.62 return _div_nearest ( _iexp ( rem , 10 ** p ) , 1000 ) , quot - p + 3