Fastest way to compute e^x?


What is the fastest way to compute e^x, given x can be a floating point value.

Right now I have used the python’s math library to compute this, below is the complete code where in result = -0.490631 + 0.774275 * math.exp(0.474907 * sum) is the main logic, rest is file handling code which the question demands.

import math
import sys

def sum_digits(n):
   r = 0
   while n:
       r, n = r + n % 10, n // 10
   return r

def _print(string):
    fo = open("output.txt", "w+")

    f = open('input.txt')
except IOError:
data =
num = data.split('n', 1)[0]
   val = int(num)
except ValueError:

sum = sum_digits(int(num))

if (sum == 2):
    result = -0.490631 + 0.774275 * math.exp(0.474907 * sum)

The rvalue of result is the equation of curve (which is the solution to a programming problem) which I derived from wolfarm-mathematica using my own data set.

But this doesn’t seem to pass the par criteria of the assessment !

I have also tried the newton-raphson way but the convergence for larger x is causing the problem, other than that, calculating the natural log ln(x) is a challenge there again !

I don’t have any language constraint so any solution is acceptable. Also if the python’s math library is fastest as some of the comments says then can anyone give an insight on the time complexity and execution time of this program, in short the efficiency of the program ?

Asked By: CMouse



I don’t know if the exponential curve math is accurate in this code, but it certainly isn’t the slow point.

First, you read the input data in one read call. It does have to be read, but that loads the entire file. The next step takes the first line only, so it would seem more appropriate to use readline. That split itself is O(n) where n is the file size, at least, which might include data you were ignoring since you only process one line.

Second, you convert that line into an int. This probably requires Python’s long integer support, but the operation could be O(n) or O(n^2). A single pass algorithm would multiply the accumulated number by 10 for each digit, allocating one or two new (longer) longs each time.

Third, sum_digits breaks that long int down into digits again. It does so using division, which is expensive, and two operations as well, rather than using divmod. That’s O(n^2), because each division has to process every higher digit for each digit. And it’s only needed because of the conversion you just did.

Summing the digits found in a string is likely easier done with something like sum(int(c) for c in l if c.isdigit()) where l is the input line. It’s not particularly fast, as there’s quite a bit of overhead in the digit conversions and the sum might grow large, but it does make a single pass with a fairly tight loop; it’s somewhere between O(n) and O(n log n), depending on the length of the data, because the sum might grow large itself.

As for the unknown exponential curve, the existence of an exception for a low number is concerning. There’s likely some other option that’s both faster and more accurate if the answer’s an integer anyway.

Lastly, you have at least four distinct output data formats: error, 2, 3.0, 3e+20. Do you know which of these is expected? Perhaps you should be using formatted output rather than str to convert your numbers.

One extra note: If the data is really large, processing it in chunks will definitely speed things up (instead of running out of memory, needing to swap, etc). As you’re looking for a digit sum your size complexity can be reduced from O(n) to O(log n).

Answered By: Yann Vernier