How to calculate the sum of the sequence without using built-in functions for exponentiation?

Question

I need to calculate the sum of the sequence in Python but I can't use the built-in functions for exponentiation.

It means I can't use ** and pow(). I have to create my own function for that.

So I created the function for exponentiation but it works only for numbers. I need to calculate my formula to the nth.

My function for exponentiation:

def exponentiation(a,b):
    result = 1
    for index in range(b):
        result = result * a
    return result

For numbers, it works. But when I want to do this to the nth (I defined 'n' as a Symbol) I get:

'Symbol' object cannot be interpreted as an integer

So I don't know how to fix that.

And if I want to calculate the sum of the sequence, I use and it works:

sy.summation((-1/2)**n, (n,1, oo))

But as I said before I need to change ** to my own exponentiation function, but it still shows that 'Symbol' object cannot be interpreted as an integer.

sy.summation(exponentiation((-1/2),n), (n,1, oo))

Do you have any advice?

Answer 1

You cannot raise 'n' to a power. I am pretty sure if you are forbidden to use ** and pow() using SymPy won't fly either.

To calculate what results in you can simply assume a "big" n and check if you can still detect any difference between the earlier result and the next result - you will not see any more changes very fast due to floating math limitations (Is floating point math broken?):

def exponentiation(a,b):
    result = 1
    for index in range(b):
        result = result * a
    return result

s = 0
a = -1/2
for n in range(1, 10000000):
    old_s = s
    s += exponentiation(a,n)

    # do not compare floats with small differences with ==
    # see link below for better ways to do that
    if s == old_s:
        print("\nThe sum no longer changes due to floating math limitations.")
        print(f"Result before: {old_s} and after {s} for n={n}")
        break
    else:
        print(f"nResult before: {old_s} and after {s} for n={n}")

Output:

Result before: 0 and after -0.5 for n=1
Result before: -0.5 and after -0.25 for n=2
Result before: -0.25 and after -0.375 for n=3
[...snipp...]
Result before: -0.33333333333333326 and after -0.33333333333333337 for n=53
Result before: -0.33333333333333337 and after -0.3333333333333333 for n=54
Result before: -0.3333333333333333 and after -0.33333333333333337 for n=55

The sum no longer changes due to floating math limitations.
Result before: -0.33333333333333337 and after -0.33333333333333337 for n=56

See What is the best way to compare floats for almost-equality in Python? for more on float comparisons.

Answer 2

The 'nth' means any given number. So you don't need to (and I can't think how you would) exponentiate any symbols. I think you can maybe simplify things a bit, if you return a list instead of just the nth value:

def exponentiation(a, n):
    result = 1
    exponents_list = []
    for i in range(n):
        result *= a
        exponents_list.append(result)
    return exponents_list

then work with the list with a for loop to get your sum

if you have to work with sympy, check this answer: Summation over a sympy Array

Answer 3

I'd say, the only meaningful solution to replace ** with Python-code is something like that:

def exponentiation(a,b):
    if isinstance(a, Symbol):
        return a.__pow__(b)
    if isinstance(b, Symbol):
        return b.__pow__(a)
    result = 1
    for index in range(b):
        result = result * a
    return result

If you want to re-implement SymPys pow function - that'd be certainly far too difficult for a Stackoverflow-answer ;).

But you can find SymPys source code here: https://github.com/sympy/sympy/blob/master/sympy/core/power.py