Euler's Number Algorithm

[Berkayasd]

Euler’s Number Algorithm

What we are asked to do is to find the form of any number to the power of e limited to m.

a = int(input("please give the number which refer to x0: "))
b = int(input("please give the number which refer to m: "))
pw = 1
c = a
fc = a
temp = a
res = 0
for i in range(2, b + 1, 1):
  while i > 0:
    pw = pw * a
    if c > 1:
      fc = fc * (c - 1)
    c = c - 1
    i = i - 1
  temp = temp + 1
  c = temp
  res = pw / fc + res
  fc = temp
  pw = 1
print(res + a + 1)

[Sky]

So, you’re attempting to compute x raised to the power of Euler’s number e, limited to the precision of m?

[Berkayasd]

Exactly. Actually, this is called Taylor sequence and the desired digits of the Euler number are calculated with this method.

[Sky]

I’m pretty sure this would work fine, I haven’t tested it but:

import math

def _compute(x, m):
    result = 0
    for i in range(m):
        result += (x ** i) / math.factorial(i)
    return result

[Berkayasd]

I think your solution looks pretty good and so easy to understand. This is my computer lab exam question and we mustn’t use any library and also power operator(**) in this exam. I wan’t to share my solution. Thanks for your reply

[Sky]

You can’t use built-in libraries?

[Sky]

I’m guessing you could use built-in libraries, but if you can’t use this:

def _compute(x, m):
  _x = sum(
      (x if i == 0 else x * term[-1]) / (factorial := 1 if j == 0 else factorial * j)
      for i, term in enumerate([[1] for _ in range(m)])
      for j in range(i + 1)
  )
  return _x

[Sky]

@Berkayasd If this solved your problem, please mark it as a solution.

[TaokyleYT]

Well if no imports can be used, we can improve some part of @Sky ’s program

@Sky

import math

def _compute(x, m):
    result = 1
    for i in range(m):
        result += (x ** i) / math.factorial(i)
    return result

To

def _compute(x, m):
    result = 1
    last_factorial = 1
    last_exponent = 1
    for i in range(m):
        result += (last_exponent / last_factorial)
        last_factorial *= i
        last_exponent *= x
    return result

I also improved the performance by a bit by saving the last factorial&exponent and multiply them with a new one instead of re-calculating factorials&exponents
And it kept it’s simplicity compared to the later solution given by @Sky

However, if m is the precision of the calculation. From what I remembered, m greater than a number below 30 (I forgot the exact number) will not be more accurate. This is because there is a limit for how many digits after decimal point is allowed in float variables. If m need to be large, the package Decimal have to be used for better precision, without import I don’t think it could work.

[Sky]

@TaokyleYT

And it kept it’s simplicity compared to the later solution given by @Sky

My code is more optimized since it uses a single loop structure and avoids repetitive calculations by using a single expression to compute the sum. So, I am willing to sacrifice a bit of readability just to get that extra optimization.