Generic implementation of powering

This implements powering of arbitrary objects using a square-and-multiply algorithm.

sage.arith.power.generic_power(a, n)

Return \(a^n\).

If \(n\) is negative, return \((1/a)^{-n}\).

INPUT:

• a – any object supporting multiplication (and division if n < 0)

• n – any integer (in the duck typing sense)

EXAMPLES:

Sage

sage: from sage.arith.power import generic_power
sage: generic_power(int(12), int(0))
1
sage: generic_power(int(0), int(100))
0
sage: generic_power(Integer(10), Integer(0))
1
sage: generic_power(Integer(0), Integer(23))
0
sage: sum([generic_power(2,i) for i in range(17)]) #test all 4-bit combinations
131071
sage: F = Zmod(5)
sage: a = generic_power(F(2), 5); a
2
sage: a.parent() is F
True
sage: a = generic_power(F(1), 2)
sage: a.parent() is F
True

sage: generic_power(int(5), 0)
1
sage: generic_power(2, 5/4)
Traceback (most recent call last):
...
NotImplementedError: non-integral exponents not supported

Python

>>> from sage.all import *
>>> from sage.arith.power import generic_power
>>> generic_power(int(Integer(12)), int(Integer(0)))
1
>>> generic_power(int(Integer(0)), int(Integer(100)))
0
>>> generic_power(Integer(Integer(10)), Integer(Integer(0)))
1
>>> generic_power(Integer(Integer(0)), Integer(Integer(23)))
0
>>> sum([generic_power(Integer(2),i) for i in range(Integer(17))]) #test all 4-bit combinations
131071
>>> F = Zmod(Integer(5))
>>> a = generic_power(F(Integer(2)), Integer(5)); a
2
>>> a.parent() is F
True
>>> a = generic_power(F(Integer(1)), Integer(2))
>>> a.parent() is F
True

>>> generic_power(int(Integer(5)), Integer(0))
1
>>> generic_power(Integer(2), Integer(5)/Integer(4))
Traceback (most recent call last):
...
NotImplementedError: non-integral exponents not supported

Sage Live

from sage.arith.power import generic_power
generic_power(int(12), int(0))
generic_power(int(0), int(100))
generic_power(Integer(10), Integer(0))
generic_power(Integer(0), Integer(23))
sum([generic_power(2,i) for i in range(17)]) #test all 4-bit combinations
F = Zmod(5)
a = generic_power(F(2), 5); a
a.parent() is F
a = generic_power(F(1), 2)
a.parent() is F
generic_power(int(5), 0)
generic_power(2, 5/4)

Sage

sage: class SymbolicMul(str):
....:     def __mul__(self, other):
....:         s = "({}*{})".format(self, other)
....:         return type(self)(s)
sage: x = SymbolicMul("x")
sage: print(generic_power(x, 7))
(((x*x)*(x*x))*((x*x)*x))

Python

>>> from sage.all import *
>>> class SymbolicMul(str):
...     def __mul__(self, other):
...         s = "({}*{})".format(self, other)
...         return type(self)(s)
>>> x = SymbolicMul("x")
>>> print(generic_power(x, Integer(7)))
(((x*x)*(x*x))*((x*x)*x))

Sage Live

class SymbolicMul(str):
    def __mul__(self, other):
        s = "({}*{})".format(self, other)
        return type(self)(s)
x = SymbolicMul("x")
print(generic_power(x, 7))

Make live